package main

import (
	"fmt"
	"html/template"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
)

// --- Test helpers ---

// testServer creates a server backed by a real git repository with sample content.
func testServer(t *testing.T) *server {
	t.Helper()

	tmpDir := t.TempDir()

	// Create a bare repo.
	repoDir := filepath.Join(tmpDir, "testrepo.git")
	gitRun(t, "", "init", "--bare", repoDir)

	// Mark it public and set metadata.
	os.WriteFile(filepath.Join(repoDir, "public"), nil, 0644)
	os.WriteFile(filepath.Join(repoDir, "description"), []byte("A test repository"), 0644)
	os.WriteFile(filepath.Join(repoDir, "owner"), []byte("tester"), 0644)

	// Clone, add content, push.
	workDir := filepath.Join(tmpDir, "work")
	gitRun(t, "", "clone", repoDir, workDir)
	gitRun(t, workDir, "config", "user.email", "test@example.com")
	gitRun(t, workDir, "config", "user.name", "Test User")

	// Create files in initial commit.
	os.WriteFile(filepath.Join(workDir, "README.md"), []byte("# Test Repo\n\nHello world.\n"), 0644)
	os.WriteFile(filepath.Join(workDir, "main.go"), []byte("package main\n\nfunc main() {}\n"), 0644)
	os.MkdirAll(filepath.Join(workDir, "pkg"), 0755)
	os.WriteFile(filepath.Join(workDir, "pkg", "lib.go"), []byte("package pkg\n"), 0644)
	gitRun(t, workDir, "add", ".")
	gitRun(t, workDir, "commit", "-m", "Initial commit")
	gitRun(t, workDir, "push", "origin", "HEAD")

	// Second commit.
	os.WriteFile(filepath.Join(workDir, "extra.txt"), []byte("extra content\n"), 0644)
	gitRun(t, workDir, "add", ".")
	gitRun(t, workDir, "commit", "-m", "Add extra file")
	gitRun(t, workDir, "push", "origin", "HEAD")

	// Tag.
	gitRun(t, workDir, "tag", "-a", "v1.0", "-m", "Release v1.0")
	gitRun(t, workDir, "push", "origin", "v1.0")

	// Feature branch with slash in name.
	gitRun(t, workDir, "checkout", "-b", "feature/test")
	os.WriteFile(filepath.Join(workDir, "feature.txt"), []byte("feature content\n"), 0644)
	gitRun(t, workDir, "add", ".")
	gitRun(t, workDir, "commit", "-m", "Add feature")
	gitRun(t, workDir, "push", "origin", "feature/test")

	git := newGitCLIBackend(repoDir)
	defaultBranch := git.getDefaultBranch()
	commit, _ := git.getCommit(defaultBranch)

	repo := &RepoInfo{
		Name:        "testrepo",
		Path:        repoDir,
		GitDir:      repoDir,
		Description: "A test repository",
		Owner:       "tester",
		Git:         git,
	}
	if commit != nil {
		repo.LastUpdated = commit.AuthorDate
	}

	tmpl, err := loadTemplates()
	if err != nil {
		t.Fatalf("loadTemplates: %v", err)
	}

	db, err := openDB(filepath.Join(tmpDir, "test.db"))
	if err != nil {
		t.Fatalf("openDB: %v", err)
	}
	t.Cleanup(func() { db.Close() })

	return &server{
		repos:       map[string]*RepoInfo{"testrepo": repo},
		sorted:      []string{"testrepo"},
		tmpl:        tmpl,
		db:          db,
		title:       "Test Forge",
		description: "test site description",
		baseURL:     "",
		scanPath:    tmpDir,
	}
}

func gitRun(t *testing.T, dir string, args ...string) {
	t.Helper()
	cmd := exec.Command("git", args...)
	if dir != "" {
		cmd.Dir = dir
	}
	cmd.Env = append(os.Environ(),
		"GIT_CONFIG_GLOBAL=/dev/null",
		"GIT_CONFIG_SYSTEM=/dev/null",
	)
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("git %v (dir=%s): %v\n%s", args, dir, err, out)
	}
}

// get sends a GET through the route dispatcher.
func get(t *testing.T, srv *server, path string) *httptest.ResponseRecorder {
	t.Helper()
	req := httptest.NewRequest(http.MethodGet, path, nil)
	w := httptest.NewRecorder()
	srv.route(w, req)
	return w
}

// getWithCookie sends a GET with a session cookie.
func getWithCookie(t *testing.T, srv *server, path, handle string) *httptest.ResponseRecorder {
	t.Helper()
	req := httptest.NewRequest(http.MethodGet, path, nil)
	req.AddCookie(&http.Cookie{Name: sessionCookieName, Value: signSession(handle)})
	w := httptest.NewRecorder()
	srv.route(w, req)
	return w
}

// postForm sends a POST with form data through the route dispatcher.
func postForm(t *testing.T, srv *server, path string, form url.Values) *httptest.ResponseRecorder {
	t.Helper()
	req := httptest.NewRequest(http.MethodPost, path, strings.NewReader(form.Encode()))
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	w := httptest.NewRecorder()
	srv.route(w, req)
	return w
}

// postFormWithCookie sends a POST with form data and a session cookie.
func postFormWithCookie(t *testing.T, srv *server, path string, form url.Values, handle string) *httptest.ResponseRecorder {
	t.Helper()
	req := httptest.NewRequest(http.MethodPost, path, strings.NewReader(form.Encode()))
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.AddCookie(&http.Cookie{Name: sessionCookieName, Value: signSession(handle)})
	w := httptest.NewRecorder()
	srv.route(w, req)
	return w
}

// getMux sends a GET through the full mux (including static asset routes).
func getMux(t *testing.T, srv *server, path string) *httptest.ResponseRecorder {
	t.Helper()
	mux := http.NewServeMux()
	mux.HandleFunc("/style.css", srv.serveCSS)
	mux.HandleFunc("/radiant.svg", srv.serveLogo)
	mux.HandleFunc("/js/", srv.serveJS)
	mux.HandleFunc("/fonts/", srv.serveFont)
	mux.HandleFunc("/", srv.route)
	req := httptest.NewRequest(http.MethodGet, path, nil)
	w := httptest.NewRecorder()
	mux.ServeHTTP(w, req)
	return w
}

// defaultRef returns the default branch name for the test repo.
func defaultRef(t *testing.T, srv *server) string {
	t.Helper()
	return srv.repos["testrepo"].Git.getDefaultBranch()
}

// latestHash returns the latest commit hash on the default branch.
func latestHash(t *testing.T, srv *server) string {
	t.Helper()
	git := srv.repos["testrepo"].Git
	h, err := git.resolveRef(git.getDefaultBranch())
	if err != nil {
		t.Fatalf("resolveRef: %v", err)
	}
	return h
}

// initialHash returns the hash of the "Initial commit".
func initialHash(t *testing.T, srv *server) string {
	t.Helper()
	git := srv.repos["testrepo"].Git
	h, _ := git.resolveRef(git.getDefaultBranch())
	commits, _, _ := git.getLog(h, 0, 50)
	for _, c := range commits {
		if c.Subject == "Initial commit" {
			return c.Hash
		}
	}
	t.Fatal("initial commit not found")
	return ""
}

func assertCode(t *testing.T, w *httptest.ResponseRecorder, want int) {
	t.Helper()
	if w.Code != want {
		n := w.Body.Len()
		if n > 500 {
			n = 500
		}
		t.Fatalf("expected status %d, got %d\nbody: %s", want, w.Code, w.Body.String()[:n])
	}
}

func assertContains(t *testing.T, w *httptest.ResponseRecorder, substr string) {
	t.Helper()
	if !strings.Contains(w.Body.String(), substr) {
		n := w.Body.Len()
		if n > 1000 {
			n = 1000
		}
		t.Errorf("expected body to contain %q\nbody: %s", substr, w.Body.String()[:n])
	}
}

func assertNotContains(t *testing.T, w *httptest.ResponseRecorder, substr string) {
	t.Helper()
	if strings.Contains(w.Body.String(), substr) {
		t.Errorf("expected body NOT to contain %q", substr)
	}
}

func assertHeader(t *testing.T, w *httptest.ResponseRecorder, key, wantSubstr string) {
	t.Helper()
	got := w.Header().Get(key)
	if !strings.Contains(got, wantSubstr) {
		t.Errorf("expected header %s to contain %q, got %q", key, wantSubstr, got)
	}
}

func assertRedirect(t *testing.T, w *httptest.ResponseRecorder, code int, locSubstr string) {
	t.Helper()
	assertCode(t, w, code)
	loc := w.Header().Get("Location")
	if !strings.Contains(loc, locSubstr) {
		t.Errorf("expected Location to contain %q, got %q", locSubstr, loc)
	}
}

// ===================================================================
// Static assets
// ===================================================================

func TestServeCSS(t *testing.T) {
	srv := testServer(t)
	w := getMux(t, srv, "/style.css")
	assertCode(t, w, 200)
	assertHeader(t, w, "Content-Type", "text/css")
	assertHeader(t, w, "Cache-Control", "public")
	if w.Body.Len() == 0 {
		t.Error("empty CSS body")
	}
}

func TestServeLogo(t *testing.T) {
	srv := testServer(t)
	w := getMux(t, srv, "/radiant.svg")
	assertCode(t, w, 200)
	assertHeader(t, w, "Content-Type", "image/svg+xml")
	assertHeader(t, w, "Cache-Control", "public")
	if w.Body.Len() == 0 {
		t.Error("empty logo body")
	}
}

func TestServeJS_Known(t *testing.T) {
	srv := testServer(t)
	for _, name := range []string{"hirad.js", "hiril.js"} {
		w := getMux(t, srv, "/js/"+name)
		assertCode(t, w, 200)
		assertHeader(t, w, "Content-Type", "javascript")
		assertHeader(t, w, "Cache-Control", "public")
		if w.Body.Len() == 0 {
			t.Errorf("empty body for %s", name)
		}
	}
}

func TestServeJS_Unknown(t *testing.T) {
	srv := testServer(t)
	w := getMux(t, srv, "/js/unknown.js")
	assertCode(t, w, 404)
}

func TestServeFont_Known(t *testing.T) {
	srv := testServer(t)
	w := getMux(t, srv, "/fonts/RethinkSans.ttf")
	assertCode(t, w, 200)
	assertHeader(t, w, "Content-Type", "font/ttf")
	assertHeader(t, w, "Cache-Control", "public")
	if w.Body.Len() == 0 {
		t.Error("empty font body")
	}
}

func TestServeFont_Unknown(t *testing.T) {
	srv := testServer(t)
	w := getMux(t, srv, "/fonts/nonexistent.ttf")
	assertCode(t, w, 404)
}

// ===================================================================
// Index page
// ===================================================================

func TestIndex(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/")
	assertCode(t, w, 200)
	assertContains(t, w, "testrepo")
	assertContains(t, w, "A test repository")
	assertContains(t, w, "Test Forge")
	assertContains(t, w, "test site description")
	// Footer
	assertContains(t, w, "Radiant Forge")
}

func TestIndex_Empty(t *testing.T) {
	srv := testServer(t)
	srv.repos = map[string]*RepoInfo{}
	srv.sorted = nil
	w := get(t, srv, "/")
	assertCode(t, w, 200)
	assertContains(t, w, "No repositories found")
}

func TestIndex_SignInLink(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/")
	assertCode(t, w, 200)
	assertContains(t, w, "Sign in")
}

func TestIndex_LoggedInShowsAvatar(t *testing.T) {
	srv := testServer(t)
	upsertAvatar(srv.db, "alice", "https://example.com/alice.png")
	w := getWithCookie(t, srv, "/", "alice")
	assertCode(t, w, 200)
	assertContains(t, w, "https://example.com/alice.png")
	assertContains(t, w, "Sign out")
}

// ===================================================================
// Repo summary (home)
// ===================================================================

func TestSummary(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/")
	assertCode(t, w, 200)
	assertContains(t, w, "testrepo")
	assertContains(t, w, "A test repository")
	// Navigation tabs
	assertContains(t, w, "home")
	assertContains(t, w, "log")
	assertContains(t, w, "refs")
	assertContains(t, w, "discussions")
	// File tree
	assertContains(t, w, "README.md")
	assertContains(t, w, "main.go")
	assertContains(t, w, "pkg")
	assertContains(t, w, "extra.txt")
	// README content
	assertContains(t, w, "Hello world")
	// Last commit
	assertContains(t, w, "Add extra file")
	assertContains(t, w, "Test User")
	// Clone URLs
	assertContains(t, w, "testrepo.git")
	// No footer on repo pages
	assertNotContains(t, w, "Powered by")
}

func TestSummary_NoTrailingSlash(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo")
	assertCode(t, w, 200)
	assertContains(t, w, "testrepo")
}

func TestSummary_BranchSelector(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/")
	assertCode(t, w, 200)
	assertContains(t, w, "feature/test")
}

func TestSummary_CloneHTTPS_XForwardedProto(t *testing.T) {
	srv := testServer(t)
	req := httptest.NewRequest(http.MethodGet, "/testrepo/", nil)
	req.Header.Set("X-Forwarded-Proto", "https")
	w := httptest.NewRecorder()
	srv.route(w, req)
	assertCode(t, w, 200)
	assertContains(t, w, "https://")
}

// ===================================================================
// Refs page
// ===================================================================

func TestRefs(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/refs")
	assertCode(t, w, 200)
	assertContains(t, w, "feature/test")
	assertContains(t, w, "v1.0")
	assertContains(t, w, "Branch")
	assertContains(t, w, "Tag")
}

// ===================================================================
// Log page
// ===================================================================

func TestLog_Default(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/log/")
	assertCode(t, w, 200)
	assertContains(t, w, "Initial commit")
	assertContains(t, w, "Add extra file")
	assertContains(t, w, "Test User")
	assertContains(t, w, "Hash")
	assertContains(t, w, "Subject")
}

func TestLog_SpecificRef(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/log/feature/test")
	assertCode(t, w, 200)
	assertContains(t, w, "Add feature")
	assertContains(t, w, "Initial commit")
}

func TestLog_Pagination(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/log/?page=0")
	assertCode(t, w, 200)
	assertContains(t, w, "Initial commit")
}

func TestLog_HighPage(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/log/"+ref+"?page=999")
	assertCode(t, w, 200)
	assertContains(t, w, "No commits found")
}

func TestLog_NegativePage(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/log/"+ref+"?page=-1")
	assertCode(t, w, 200)
	// Negative clamped to 0, should show commits.
	assertContains(t, w, "Initial commit")
}

func TestLog_InvalidRef(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/log/nonexistent-ref")
	assertCode(t, w, 200)
	// Renders the empty log page.
}

func TestLog_BranchSelector(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/log/")
	assertCode(t, w, 200)
	assertContains(t, w, "feature/test")
}

// ===================================================================
// Tree page
// ===================================================================

func TestTree_Root(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/tree/"+ref)
	assertCode(t, w, 200)
	assertContains(t, w, "main.go")
	assertContains(t, w, "pkg")
	assertContains(t, w, "README.md")
}

func TestTree_Directory(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/tree/"+ref+"/pkg")
	assertCode(t, w, 200)
	assertContains(t, w, "lib.go")
}

func TestTree_File(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/tree/"+ref+"/main.go")
	assertCode(t, w, 200)
	assertContains(t, w, "package main")
	assertContains(t, w, "func main()")
	assertContains(t, w, "main.go")
	assertContains(t, w, "/raw/")
}

func TestTree_NestedFile(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/tree/"+ref+"/pkg/lib.go")
	assertCode(t, w, 200)
	assertContains(t, w, "package pkg")
}

func TestTree_BranchWithSlash(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/tree/feature/test")
	assertCode(t, w, 200)
	assertContains(t, w, "feature.txt")
}

func TestTree_BranchWithSlash_File(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/tree/feature/test/feature.txt")
	assertCode(t, w, 200)
	assertContains(t, w, "feature content")
}

func TestTree_EmptyRest(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/tree/")
	assertCode(t, w, 200)
	assertContains(t, w, "main.go")
}

func TestTree_InvalidRef(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/tree/nonexistent-ref")
	assertCode(t, w, 404)
	assertContains(t, w, "Ref not found")
}

func TestTree_FileNotFound(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/tree/"+ref+"/no-such-file.txt")
	assertCode(t, w, 404)
	assertContains(t, w, "File not found")
}

func TestTree_LineNumbers(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/tree/"+ref+"/main.go")
	assertCode(t, w, 200)
	assertContains(t, w, `id="L1"`)
	assertContains(t, w, `href="#L1"`)
}

func TestTree_FileShowsSize(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/tree/"+ref+"/main.go")
	assertCode(t, w, 200)
	// formatSize should produce "X B" for small files.
	assertContains(t, w, " B")
}

// ===================================================================
// Commit page
// ===================================================================

func TestCommit(t *testing.T) {
	srv := testServer(t)
	hash := latestHash(t, srv)
	w := get(t, srv, "/testrepo/commit/"+hash)
	assertCode(t, w, 200)
	assertContains(t, w, "Add extra file")
	assertContains(t, w, "Test User")
	assertContains(t, w, hash)
	assertContains(t, w, "extra.txt")
	assertContains(t, w, "parent")
}

func TestCommit_Initial(t *testing.T) {
	srv := testServer(t)
	hash := initialHash(t, srv)
	w := get(t, srv, "/testrepo/commit/"+hash)
	assertCode(t, w, 200)
	assertContains(t, w, "Initial commit")
	assertContains(t, w, "README.md")
	assertContains(t, w, "main.go")
}

func TestCommit_NotFound(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/commit/deadbeefdeadbeefdeadbeefdeadbeefdeadbeef")
	assertCode(t, w, 404)
	assertContains(t, w, "Commit not found")
}

func TestCommit_CommitHashInNav(t *testing.T) {
	srv := testServer(t)
	hash := latestHash(t, srv)
	w := get(t, srv, "/testrepo/commit/"+hash)
	assertCode(t, w, 200)
	assertContains(t, w, hash[:8])
}

func TestCommit_DiffStats(t *testing.T) {
	srv := testServer(t)
	hash := latestHash(t, srv)
	w := get(t, srv, "/testrepo/commit/"+hash)
	assertCode(t, w, 200)
	// Diff stats: +N -N
	assertContains(t, w, "added")
}

// ===================================================================
// Raw file download
// ===================================================================

func TestRaw(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/raw/"+ref+"/main.go")
	assertCode(t, w, 200)
	assertHeader(t, w, "Content-Type", "text/plain")
	if !strings.Contains(w.Body.String(), "package main") {
		t.Error("expected raw file content")
	}
	cl := w.Header().Get("Content-Length")
	if cl == "" || cl == "0" {
		t.Error("expected non-zero Content-Length")
	}
}

func TestRaw_Markdown(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/raw/"+ref+"/README.md")
	assertCode(t, w, 200)
	assertHeader(t, w, "Content-Type", "text/plain")
	assertContains(t, w, "# Test Repo")
}

func TestRaw_NoPath(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/raw/")
	assertCode(t, w, 404)
	assertContains(t, w, "No path specified")
}

func TestRaw_RefOnly(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/raw/"+ref)
	assertCode(t, w, 404)
	assertContains(t, w, "No file path")
}

func TestRaw_InvalidRef(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/raw/nonexistent/file.txt")
	assertCode(t, w, 404)
	assertContains(t, w, "Ref not found")
}

func TestRaw_FileNotFound(t *testing.T) {
	srv := testServer(t)
	ref := defaultRef(t, srv)
	w := get(t, srv, "/testrepo/raw/"+ref+"/no-such-file.txt")
	assertCode(t, w, 404)
	assertContains(t, w, "File not found")
}

// ===================================================================
// Routing: repo not found, unknown action, .git suffix
// ===================================================================

func TestRoute_RepoNotFound(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/nonexistent/")
	assertCode(t, w, 404)
	assertContains(t, w, "Repository not found")
}

func TestRoute_UnknownAction(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/foobar")
	assertCode(t, w, 404)
	assertContains(t, w, "Page not found")
}

func TestRoute_RepoNameDotGit(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo.git/refs")
	assertCode(t, w, 200)
	assertContains(t, w, "feature/test")
}

// ===================================================================
// Base URL prefix
// ===================================================================

func TestBaseURL_Index(t *testing.T) {
	srv := testServer(t)
	srv.baseURL = "/git"
	req := httptest.NewRequest(http.MethodGet, "/git/", nil)
	w := httptest.NewRecorder()
	srv.route(w, req)
	assertCode(t, w, 200)
	assertContains(t, w, "/git/testrepo/")
}

func TestBaseURL_Summary(t *testing.T) {
	srv := testServer(t)
	srv.baseURL = "/git"
	req := httptest.NewRequest(http.MethodGet, "/git/testrepo/", nil)
	w := httptest.NewRecorder()
	srv.route(w, req)
	assertCode(t, w, 200)
	assertContains(t, w, "/git/testrepo/")
}

func TestBaseURL_LinksInRepoPages(t *testing.T) {
	srv := testServer(t)
	srv.baseURL = "/code"
	req := httptest.NewRequest(http.MethodGet, "/code/testrepo/refs", nil)
	w := httptest.NewRecorder()
	srv.route(w, req)
	assertCode(t, w, 200)
	assertContains(t, w, "/code/testrepo/log/")
	assertContains(t, w, "/code/testrepo/commit/")
}

// ===================================================================
// Basic auth
// ===================================================================

func TestBasicAuth_NoCredentials(t *testing.T) {
	srv := testServer(t)
	srv.username = "admin"
	srv.password = "secret"
	mux := http.NewServeMux()
	mux.HandleFunc("/", srv.route)
	handler := srv.basicAuth(mux)

	req := httptest.NewRequest(http.MethodGet, "/", nil)
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)
	assertCode(t, w, 401)
	assertHeader(t, w, "WWW-Authenticate", "Basic")
}

func TestBasicAuth_WrongCredentials(t *testing.T) {
	srv := testServer(t)
	srv.username = "admin"
	srv.password = "secret"
	mux := http.NewServeMux()
	mux.HandleFunc("/", srv.route)
	handler := srv.basicAuth(mux)

	req := httptest.NewRequest(http.MethodGet, "/", nil)
	req.SetBasicAuth("admin", "wrong")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)
	assertCode(t, w, 401)
}

func TestBasicAuth_CorrectCredentials(t *testing.T) {
	srv := testServer(t)
	srv.username = "admin"
	srv.password = "secret"
	mux := http.NewServeMux()
	mux.HandleFunc("/", srv.route)
	handler := srv.basicAuth(mux)

	req := httptest.NewRequest(http.MethodGet, "/", nil)
	req.SetBasicAuth("admin", "secret")
	w := httptest.NewRecorder()
	handler.ServeHTTP(w, req)
	assertCode(t, w, 200)
}

// ===================================================================
// Error page
// ===================================================================

func TestRenderError(t *testing.T) {
	srv := testServer(t)
	req := httptest.NewRequest(http.MethodGet, "/bad-path", nil)
	w := httptest.NewRecorder()
	srv.renderError(w, req, 404, "Something went wrong")
	assertCode(t, w, 404)
	assertContains(t, w, "Something went wrong")
	assertContains(t, w, "404")
	assertContains(t, w, "/bad-path")
	assertContains(t, w, "Back to index")
}

// ===================================================================
// Discussions
// ===================================================================

func TestDiscussions_ListEmpty(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/discussions")
	assertCode(t, w, 200)
	assertContains(t, w, "No discussions yet")
	assertContains(t, w, "discussions")
}

func TestDiscussions_ListWithItems(t *testing.T) {
	srv := testServer(t)
	createDiscussion(srv.db, "testrepo", "First Thread", "body1", "alice")
	createDiscussion(srv.db, "testrepo", "Second Thread", "body2", "bob")

	w := get(t, srv, "/testrepo/discussions")
	assertCode(t, w, 200)
	assertContains(t, w, "First Thread")
	assertContains(t, w, "Second Thread")
	assertContains(t, w, "alice")
	assertContains(t, w, "bob")
	assertNotContains(t, w, "No discussions yet")
}

func TestDiscussions_ListShowsReplyCount(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "testrepo", "With Replies", "", "alice")
	createReply(srv.db, int(id), "reply 1", "bob")
	createReply(srv.db, int(id), "reply 2", "carol")

	w := get(t, srv, "/testrepo/discussions")
	assertCode(t, w, 200)
	assertContains(t, w, ">2<")
}

func TestDiscussions_ListOnlyShowsCurrentRepo(t *testing.T) {
	srv := testServer(t)
	createDiscussion(srv.db, "testrepo", "Mine", "", "alice")
	createDiscussion(srv.db, "other", "Not Mine", "", "bob")

	w := get(t, srv, "/testrepo/discussions")
	assertCode(t, w, 200)
	assertContains(t, w, "Mine")
	assertNotContains(t, w, "Not Mine")
}

func TestDiscussions_ListShowsNewButtonWhenLoggedIn(t *testing.T) {
	srv := testServer(t)
	w := getWithCookie(t, srv, "/testrepo/discussions", "alice")
	assertCode(t, w, 200)
	assertContains(t, w, "New discussion")
}

func TestDiscussions_ListHidesNewButtonWhenLoggedOut(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/discussions")
	assertCode(t, w, 200)
	assertNotContains(t, w, "New discussion")
}

func TestDiscussions_NewRedirectsWhenNotLoggedIn(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/discussions/new")
	assertRedirect(t, w, 303, "login")
}

func TestDiscussions_NewPageWhenLoggedIn(t *testing.T) {
	srv := testServer(t)
	w := getWithCookie(t, srv, "/testrepo/discussions/new", "alice")
	assertCode(t, w, 200)
	assertContains(t, w, "New discussion")
	assertContains(t, w, "Title")
	assertContains(t, w, "Create discussion")
}

func TestDiscussions_CreateSuccess(t *testing.T) {
	srv := testServer(t)
	form := url.Values{"title": {"My Discussion"}, "body": {"Discussion body."}}
	w := postFormWithCookie(t, srv, "/testrepo/discussions/new", form, "alice")
	assertRedirect(t, w, 303, "/testrepo/discussions/")

	// Verify persisted.
	list := listDiscussions(srv.db, "testrepo")
	if len(list) != 1 {
		t.Fatalf("expected 1, got %d", len(list))
	}
	if list[0].Title != "My Discussion" {
		t.Errorf("title: got %q", list[0].Title)
	}
	if list[0].Author != "alice" {
		t.Errorf("author: got %q", list[0].Author)
	}
}

func TestDiscussions_CreateEmptyTitle(t *testing.T) {
	srv := testServer(t)
	form := url.Values{"title": {""}, "body": {"some body"}}
	w := postFormWithCookie(t, srv, "/testrepo/discussions/new", form, "alice")
	assertCode(t, w, 200)
	assertContains(t, w, "Title is required")
}

func TestDiscussions_CreateNotLoggedIn(t *testing.T) {
	srv := testServer(t)
	form := url.Values{"title": {"Title"}, "body": {"body"}}
	w := postForm(t, srv, "/testrepo/discussions/new", form)
	assertRedirect(t, w, 303, "login")
}

func TestDiscussions_ViewDiscussion(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "testrepo", "View Me", "Look at this body", "alice")
	createReply(srv.db, int(id), "A thoughtful reply", "bob")

	w := get(t, srv, fmt.Sprintf("/testrepo/discussions/%d", id))
	assertCode(t, w, 200)
	assertContains(t, w, "View Me")
	assertContains(t, w, "Look at this body")
	assertContains(t, w, "alice")
	assertContains(t, w, "A thoughtful reply")
	assertContains(t, w, "bob")
	assertContains(t, w, "Sign in")
}

func TestDiscussions_ViewDiscussionLoggedIn(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "testrepo", "Logged In View", "", "alice")

	w := getWithCookie(t, srv, fmt.Sprintf("/testrepo/discussions/%d", id), "bob")
	assertCode(t, w, 200)
	assertContains(t, w, "Reply as")
	assertContains(t, w, "bob")
	assertContains(t, w, "Post reply")
}

func TestDiscussions_ViewNotFound(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/discussions/99999")
	assertCode(t, w, 404)
	assertContains(t, w, "Discussion not found")
}

func TestDiscussions_ViewInvalidID(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/testrepo/discussions/abc")
	assertCode(t, w, 404)
	assertContains(t, w, "Discussion not found")
}

func TestDiscussions_ViewWrongRepo(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "otherrepo", "Wrong Repo", "", "alice")
	w := get(t, srv, fmt.Sprintf("/testrepo/discussions/%d", id))
	assertCode(t, w, 404)
	assertContains(t, w, "Discussion not found")
}

func TestDiscussions_Reply(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "testrepo", "Reply Target", "", "alice")

	form := url.Values{"body": {"My reply text"}}
	w := postFormWithCookie(t, srv, fmt.Sprintf("/testrepo/discussions/%d", id), form, "bob")
	assertRedirect(t, w, 303, fmt.Sprintf("/testrepo/discussions/%d#reply-", id))

	replies := getReplies(srv.db, int(id))
	if len(replies) != 1 {
		t.Fatalf("expected 1 reply, got %d", len(replies))
	}
	if replies[0].Body != "My reply text" {
		t.Errorf("body: got %q", replies[0].Body)
	}
	if replies[0].Author != "bob" {
		t.Errorf("author: got %q", replies[0].Author)
	}
}

func TestDiscussions_ReplyEmptyBody(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "testrepo", "Reply Target", "", "alice")

	form := url.Values{"body": {""}}
	w := postFormWithCookie(t, srv, fmt.Sprintf("/testrepo/discussions/%d", id), form, "bob")
	assertCode(t, w, 200)
	assertContains(t, w, "Reply cannot be empty")
}

func TestDiscussions_ReplyNotLoggedIn(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "testrepo", "Reply Target", "", "alice")

	form := url.Values{"body": {"attempt"}}
	w := postForm(t, srv, fmt.Sprintf("/testrepo/discussions/%d", id), form)
	assertCode(t, w, 403)
	assertContains(t, w, "must be signed in")
}

// ===================================================================
// Login / Logout
// ===================================================================

func TestLogin_Page(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/login")
	assertCode(t, w, 200)
	assertContains(t, w, "Sign in with")
	assertContains(t, w, "Bluesky")
	assertContains(t, w, "handle")
	assertContains(t, w, "app_password")
}

func TestLogin_PageWithReturn(t *testing.T) {
	srv := testServer(t)
	w := get(t, srv, "/login?return=/testrepo/discussions")
	assertCode(t, w, 200)
	assertContains(t, w, "/testrepo/discussions")
}

func TestLogin_PostMissingFields(t *testing.T) {
	srv := testServer(t)
	form := url.Values{"handle": {""}, "app_password": {""}}
	w := postForm(t, srv, "/login", form)
	assertCode(t, w, 200)
	assertContains(t, w, "Handle and app password are required")
}

func TestLogin_PostMissingPassword(t *testing.T) {
	srv := testServer(t)
	form := url.Values{"handle": {"alice.bsky.social"}, "app_password": {""}}
	w := postForm(t, srv, "/login", form)
	assertCode(t, w, 200)
	assertContains(t, w, "Handle and app password are required")
}

func TestLogout(t *testing.T) {
	srv := testServer(t)
	req := httptest.NewRequest(http.MethodGet, "/logout", nil)
	req.AddCookie(&http.Cookie{Name: sessionCookieName, Value: signSession("alice")})
	w := httptest.NewRecorder()
	srv.route(w, req)
	assertRedirect(t, w, 303, "/")

	found := false
	for _, c := range w.Result().Cookies() {
		if c.Name == sessionCookieName && c.MaxAge < 0 {
			found = true
		}
	}
	if !found {
		t.Error("expected session cookie to be cleared")
	}
}

func TestLogout_WithReturn(t *testing.T) {
	srv := testServer(t)
	req := httptest.NewRequest(http.MethodGet, "/logout?return=/testrepo/", nil)
	w := httptest.NewRecorder()
	srv.route(w, req)
	assertRedirect(t, w, 303, "/testrepo/")
}

func TestLogout_DefaultReturn(t *testing.T) {
	srv := testServer(t)
	req := httptest.NewRequest(http.MethodGet, "/logout", nil)
	w := httptest.NewRecorder()
	srv.route(w, req)
	assertRedirect(t, w, 303, "/")
}

// ===================================================================
// isGitHTTPRequest
// ===================================================================

func TestIsGitHTTPRequest(t *testing.T) {
	tests := []struct {
		path  string
		query string
		want  bool
	}{
		{"/repo/info/refs", "service=git-upload-pack", true},
		{"/repo/info/refs", "service=git-receive-pack", true},
		{"/repo/info/refs", "", false},
		{"/repo/git-upload-pack", "", true},
		{"/repo/git-receive-pack", "", true},
		{"/repo/HEAD", "", true},
		{"/repo/objects/pack/pack-abc.pack", "", true},
		{"/repo/refs", "", false},
		{"/repo/", "", false},
		{"/repo/tree/main", "", false},
	}
	for _, tt := range tests {
		u := tt.path
		if tt.query != "" {
			u += "?" + tt.query
		}
		req := httptest.NewRequest(http.MethodGet, u, nil)
		got := isGitHTTPRequest(req)
		if got != tt.want {
			t.Errorf("isGitHTTPRequest(%q, %q) = %v, want %v", tt.path, tt.query, got, tt.want)
		}
	}
}

// ===================================================================
// Session sign / verify
// ===================================================================

func TestSession_SignAndVerify(t *testing.T) {
	signed := signSession("alice")
	handle, ok := verifySession(signed)
	if !ok {
		t.Fatal("expected valid session")
	}
	if handle != "alice" {
		t.Errorf("expected alice, got %q", handle)
	}
}

func TestSession_Garbage(t *testing.T) {
	if _, ok := verifySession("garbage"); ok {
		t.Error("expected invalid")
	}
}

func TestSession_Tampered(t *testing.T) {
	signed := signSession("alice")
	tampered := signed[:len(signed)-2] + "ff"
	if _, ok := verifySession(tampered); ok {
		t.Error("expected tampered session to be invalid")
	}
}

func TestSession_TwoParts(t *testing.T) {
	if _, ok := verifySession("a|b"); ok {
		t.Error("expected invalid with only 2 parts")
	}
}

func TestSession_ExpiredTimestamp(t *testing.T) {
	if _, ok := verifySession("alice|1000000000|fakesig"); ok {
		t.Error("expected expired session to be invalid")
	}
}

func TestSession_BadExpiry(t *testing.T) {
	if _, ok := verifySession("alice|notanumber|fakesig"); ok {
		t.Error("expected invalid with bad expiry")
	}
}

func TestGetSessionHandle_NoCookie(t *testing.T) {
	req := httptest.NewRequest(http.MethodGet, "/", nil)
	if h := getSessionHandle(req); h != "" {
		t.Errorf("expected empty, got %q", h)
	}
}

func TestGetSessionHandle_ValidCookie(t *testing.T) {
	req := httptest.NewRequest(http.MethodGet, "/", nil)
	req.AddCookie(&http.Cookie{Name: sessionCookieName, Value: signSession("bob")})
	if h := getSessionHandle(req); h != "bob" {
		t.Errorf("expected bob, got %q", h)
	}
}

func TestGetSessionHandle_InvalidCookie(t *testing.T) {
	req := httptest.NewRequest(http.MethodGet, "/", nil)
	req.AddCookie(&http.Cookie{Name: sessionCookieName, Value: "bad"})
	if h := getSessionHandle(req); h != "" {
		t.Errorf("expected empty, got %q", h)
	}
}

func TestSetSessionCookie(t *testing.T) {
	w := httptest.NewRecorder()
	setSessionCookie(w, "carol")
	found := false
	for _, c := range w.Result().Cookies() {
		if c.Name == sessionCookieName {
			found = true
			if !c.HttpOnly {
				t.Error("expected HttpOnly")
			}
			if c.MaxAge <= 0 {
				t.Error("expected positive MaxAge")
			}
			h, ok := verifySession(c.Value)
			if !ok || h != "carol" {
				t.Error("cookie value doesn't verify")
			}
		}
	}
	if !found {
		t.Error("session cookie not set")
	}
}

func TestClearSessionCookie(t *testing.T) {
	w := httptest.NewRecorder()
	clearSessionCookie(w)
	found := false
	for _, c := range w.Result().Cookies() {
		if c.Name == sessionCookieName {
			found = true
			if c.MaxAge >= 0 {
				t.Error("expected negative MaxAge")
			}
		}
	}
	if !found {
		t.Error("session cookie not set for clearing")
	}
}

// ===================================================================
// Database CRUD
// ===================================================================

func TestDB_DiscussionCRUD(t *testing.T) {
	srv := testServer(t)

	id, err := createDiscussion(srv.db, "testrepo", "DB Title", "DB Body", "author1")
	if err != nil {
		t.Fatalf("createDiscussion: %v", err)
	}
	if id == 0 {
		t.Fatal("expected non-zero ID")
	}

	d, err := getDiscussion(srv.db, int(id))
	if err != nil {
		t.Fatalf("getDiscussion: %v", err)
	}
	if d.Title != "DB Title" {
		t.Errorf("title: %q", d.Title)
	}
	if d.Body != "DB Body" {
		t.Errorf("body: %q", d.Body)
	}
	if d.Author != "author1" {
		t.Errorf("author: %q", d.Author)
	}
	if d.Repo != "testrepo" {
		t.Errorf("repo: %q", d.Repo)
	}
}

func TestDB_Replies(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "testrepo", "T", "", "a")
	createReply(srv.db, int(id), "Reply one", "user1")
	createReply(srv.db, int(id), "Reply two", "user2")

	replies := getReplies(srv.db, int(id))
	if len(replies) != 2 {
		t.Fatalf("expected 2, got %d", len(replies))
	}
	if replies[0].Body != "Reply one" || replies[0].Author != "user1" {
		t.Errorf("reply 0: %+v", replies[0])
	}
	if replies[1].Body != "Reply two" || replies[1].Author != "user2" {
		t.Errorf("reply 1: %+v", replies[1])
	}
}

func TestDB_RepliesEmpty(t *testing.T) {
	srv := testServer(t)
	if replies := getReplies(srv.db, 99999); len(replies) != 0 {
		t.Errorf("expected 0, got %d", len(replies))
	}
}

func TestDB_GetDiscussionNotFound(t *testing.T) {
	srv := testServer(t)
	if _, err := getDiscussion(srv.db, 99999); err == nil {
		t.Error("expected error")
	}
}

func TestDB_ReplyCount(t *testing.T) {
	srv := testServer(t)
	id, _ := createDiscussion(srv.db, "testrepo", "Count", "", "a")
	createReply(srv.db, int(id), "r1", "b")
	createReply(srv.db, int(id), "r2", "c")
	createReply(srv.db, int(id), "r3", "d")

	list := listDiscussions(srv.db, "testrepo")
	if len(list) != 1 {
		t.Fatalf("expected 1, got %d", len(list))
	}
	if list[0].ReplyCount != 3 {
		t.Errorf("expected 3 replies, got %d", list[0].ReplyCount)
	}
}

func TestDB_AvatarUpsert(t *testing.T) {
	srv := testServer(t)
	upsertAvatar(srv.db, "alice", "https://example.com/v1.png")
	if u := getAvatar(srv.db, "alice"); u != "https://example.com/v1.png" {
		t.Errorf("got %q", u)
	}
	upsertAvatar(srv.db, "alice", "https://example.com/v2.png")
	if u := getAvatar(srv.db, "alice"); u != "https://example.com/v2.png" {
		t.Errorf("got %q", u)
	}
}

func TestDB_AvatarNotFound(t *testing.T) {
	srv := testServer(t)
	if u := getAvatar(srv.db, "nobody"); u != "" {
		t.Errorf("expected empty, got %q", u)
	}
}

func TestDB_AvatarShownInDiscussion(t *testing.T) {
	srv := testServer(t)
	upsertAvatar(srv.db, "alice", "https://example.com/alice-av.png")
	id, _ := createDiscussion(srv.db, "testrepo", "Avatar Test", "body", "alice")

	w := get(t, srv, fmt.Sprintf("/testrepo/discussions/%d", id))
	assertCode(t, w, 200)
	assertContains(t, w, "https://example.com/alice-av.png")
}

// ===================================================================
// scanRepositories
// ===================================================================

func TestScanRepositories(t *testing.T) {
	srv := testServer(t)
	repos, err := scanRepositories(srv.scanPath, false)
	if err != nil {
		t.Fatalf("scanRepositories: %v", err)
	}
	if len(repos) != 1 {
		t.Fatalf("expected 1, got %d", len(repos))
	}
	repo := repos["testrepo"]
	if repo == nil {
		t.Fatal("expected 'testrepo'")
	}
	if repo.Description != "A test repository" {
		t.Errorf("description: %q", repo.Description)
	}
	if repo.Owner != "tester" {
		t.Errorf("owner: %q", repo.Owner)
	}
	if repo.LastUpdated.IsZero() {
		t.Error("expected non-zero LastUpdated")
	}
}

func TestScanRepositories_SkipsPrivate(t *testing.T) {
	tmpDir := t.TempDir()
	gitRun(t, "", "init", "--bare", filepath.Join(tmpDir, "private.git"))
	repos, _ := scanRepositories(tmpDir, false)
	if len(repos) != 0 {
		t.Errorf("expected 0, got %d", len(repos))
	}
}

func TestScanRepositories_SkipsHiddenDirs(t *testing.T) {
	tmpDir := t.TempDir()
	repoDir := filepath.Join(tmpDir, ".hidden.git")
	gitRun(t, "", "init", "--bare", repoDir)
	os.WriteFile(filepath.Join(repoDir, "public"), nil, 0644)
	repos, _ := scanRepositories(tmpDir, false)
	if len(repos) != 0 {
		t.Errorf("expected 0, got %d", len(repos))
	}
}

func TestScanRepositories_SkipsFiles(t *testing.T) {
	tmpDir := t.TempDir()
	os.WriteFile(filepath.Join(tmpDir, "not-a-dir"), []byte("x"), 0644)
	repos, _ := scanRepositories(tmpDir, false)
	if len(repos) != 0 {
		t.Errorf("expected 0, got %d", len(repos))
	}
}

func TestScanRepositories_NonBare(t *testing.T) {
	tmpDir := t.TempDir()
	workDir := filepath.Join(tmpDir, "myrepo")
	gitRun(t, "", "init", workDir)
	os.WriteFile(filepath.Join(workDir, ".git", "public"), nil, 0644)

	repos, _ := scanRepositories(tmpDir, false)
	if len(repos) != 0 {
		t.Errorf("expected 0 without flag, got %d", len(repos))
	}
	repos, _ = scanRepositories(tmpDir, true)
	if len(repos) != 1 {
		t.Fatalf("expected 1 with flag, got %d", len(repos))
	}
}

func TestScanRepositories_StripsGitSuffix(t *testing.T) {
	srv := testServer(t)
	repos, _ := scanRepositories(srv.scanPath, false)
	if _, ok := repos["testrepo"]; !ok {
		t.Error("expected .git suffix stripped")
	}
}

func TestScanRepositories_DefaultDescription(t *testing.T) {
	tmpDir := t.TempDir()
	repoDir := filepath.Join(tmpDir, "repo.git")
	gitRun(t, "", "init", "--bare", repoDir)
	os.WriteFile(filepath.Join(repoDir, "public"), nil, 0644)
	repos, _ := scanRepositories(tmpDir, false)
	if r, ok := repos["repo"]; ok && r.Description != "" {
		t.Errorf("default description should be empty, got %q", r.Description)
	}
}

// ===================================================================
// isBareRepo / isWorkTreeRepo
// ===================================================================

func TestIsBareRepo(t *testing.T) {
	tmpDir := t.TempDir()
	repoDir := filepath.Join(tmpDir, "bare.git")
	gitRun(t, "", "init", "--bare", repoDir)
	if !isBareRepo(repoDir) {
		t.Error("expected bare repo")
	}
	if isBareRepo(tmpDir) {
		t.Error("tmpDir is not bare")
	}
}

func TestIsWorkTreeRepo(t *testing.T) {
	tmpDir := t.TempDir()
	workDir := filepath.Join(tmpDir, "work")
	gitRun(t, "", "init", workDir)
	if !isWorkTreeRepo(workDir) {
		t.Error("expected work tree repo")
	}
	if isWorkTreeRepo(tmpDir) {
		t.Error("tmpDir is not work tree")
	}
}

// ===================================================================
// Template FuncMap
// ===================================================================

func TestFuncMap_ShortHash(t *testing.T) {
	fn := funcMap["shortHash"].(func(string) string)
	if got := fn("abcdef1234567890"); got != "abcdef12" {
		t.Errorf("got %q", got)
	}
	if got := fn("abc"); got != "abc" {
		t.Errorf("got %q", got)
	}
	if got := fn(""); got != "" {
		t.Errorf("got %q", got)
	}
}

func TestFuncMap_StatusLabel(t *testing.T) {
	fn := funcMap["statusLabel"].(func(string) string)
	cases := map[string]string{"A": "added", "D": "deleted", "M": "modified", "R": "renamed", "X": "X"}
	for in, want := range cases {
		if got := fn(in); got != want {
			t.Errorf("statusLabel(%q) = %q, want %q", in, got, want)
		}
	}
}

func TestFuncMap_FormatSize(t *testing.T) {
	fn := funcMap["formatSize"].(func(int64) string)
	if got := fn(500); got != "500 B" {
		t.Errorf("got %q", got)
	}
	if got := fn(2048); !strings.Contains(got, "KiB") {
		t.Errorf("got %q", got)
	}
	if got := fn(2 * 1024 * 1024); !strings.Contains(got, "MiB") {
		t.Errorf("got %q", got)
	}
}

func TestFuncMap_DiffFileName(t *testing.T) {
	fn := funcMap["diffFileName"].(func(DiffFile) string)
	if got := fn(DiffFile{OldName: "old.go", NewName: "new.go"}); got != "new.go" {
		t.Errorf("got %q", got)
	}
	if got := fn(DiffFile{OldName: "old.go", NewName: ""}); got != "old.go" {
		t.Errorf("got %q", got)
	}
}

func TestFuncMap_ParentPath(t *testing.T) {
	fn := funcMap["parentPath"].(func(string) string)
	if got := fn("a/b/c"); got != "a/b" {
		t.Errorf("got %q", got)
	}
	if got := fn("file.go"); got != "" {
		t.Errorf("got %q", got)
	}
}

func TestFuncMap_Indent(t *testing.T) {
	fn := funcMap["indent"].(func(int) string)
	if got := fn(0); got != "" {
		t.Errorf("got %q", got)
	}
	if got := fn(2); !strings.Contains(got, "padding-left") {
		t.Errorf("got %q", got)
	}
}

func TestFuncMap_LangClass(t *testing.T) {
	fn := funcMap["langClass"].(func(string) string)
	if got := fn("file.rad"); got != "language-radiance" {
		t.Errorf("got %q", got)
	}
	if got := fn("file.ril"); got != "language-ril" {
		t.Errorf("got %q", got)
	}
	if got := fn("file.go"); got != "" {
		t.Errorf("got %q", got)
	}
}

func TestFuncMap_Add(t *testing.T) {
	fn := funcMap["add"].(func(int, int) int)
	if got := fn(3, 4); got != 7 {
		t.Errorf("got %d", got)
	}
}

func TestFuncMap_Autolink(t *testing.T) {
	fn := funcMap["autolink"].(func(string) template.HTML)
	tests := []struct {
		input    string
		contains string
	}{
		{"hello https://example.com world", `<a href="https://example.com">https://example.com</a>`},
		{"no links here", "no links here"},
		{"http://foo.com.", `<a href="http://foo.com">http://foo.com</a>`},
		{"<script>", "&lt;script&gt;"},
	}
	for _, tt := range tests {
		got := string(fn(tt.input))
		if !strings.Contains(got, tt.contains) {
			t.Errorf("autolink(%q):\n  got:  %s\n  want substring: %s", tt.input, got, tt.contains)
		}
	}
}

func TestFormatInline(t *testing.T) {
	tests := []struct {
		input string
		want  string
	}{
		// Backtick code
		{"use `fmt.Println` here", "use <code>fmt.Println</code> here"},
		// Code with special chars
		{"run `<script>`", "run <code>&lt;script&gt;</code>"},
		// Italic
		{"this is *important* stuff", "this is <em>important</em> stuff"},
		// Single-char italic
		{"*a* test", "<em>a</em> test"},
		// Angle-bracket link
		{"see <https://example.com> for info", `see <a href="https://example.com">https://example.com</a> for info`},
		// Bare URL (existing behavior)
		{"visit https://example.com today", `visit <a href="https://example.com">https://example.com</a> today`},
		// Bare URL with trailing punctuation
		{"see https://example.com.", `see <a href="https://example.com">https://example.com</a>.`},
		// Mixed formatting
		{"use `code` and *italic* and <https://x.com>",
			`use <code>code</code> and <em>italic</em> and <a href="https://x.com">https://x.com</a>`},
		// No formatting
		{"plain text", "plain text"},
		// HTML escaping in plain text
		{"<b>bold</b>", "&lt;b&gt;bold&lt;/b&gt;"},
		// Asterisk without match (not italic)
		{"a * b * c", "a * b * c"},
		// Italic must not have leading/trailing spaces
		{"not * italic *", "not * italic *"},
	}
	for _, tt := range tests {
		got := formatInline(tt.input)
		if got != tt.want {
			t.Errorf("formatInline(%q):\n  got:  %s\n  want: %s", tt.input, got, tt.want)
		}
	}
}

func TestFuncMap_FormatBody(t *testing.T) {
	fn := funcMap["formatBody"].(func(string) template.HTML)
	tests := []struct {
		input string
		want  string
	}{
		// Single paragraph with code
		{"hello `world`", "<p>hello <code>world</code></p>"},
		// Two paragraphs
		{"first\n\nsecond", "<p>first</p><p>second</p>"},
		// Paragraph with italic and link
		{"*wow* see <https://x.com>", `<p><em>wow</em> see <a href="https://x.com">https://x.com</a></p>`},
		// Empty input
		{"", ""},
		{"  \n\n  ", ""},
		// Fenced code block
		{"before\n\n```\nfmt.Println(\"hi\")\n```\n\nafter",
			"<p>before</p><pre><code>fmt.Println(&#34;hi&#34;)</code></pre><p>after</p>"},
		// Code block with language tag
		{"```go\npackage main\n```",
			"<pre><code>package main</code></pre>"},
		// Code block only
		{"```\nline1\nline2\n```",
			"<pre><code>line1\nline2</code></pre>"},
		// No inline formatting inside code blocks
		{"```\n*not italic* `not code`\n```",
			"<pre><code>*not italic* `not code`</code></pre>"},
		// Unclosed code block
		{"```\nhello",
			"<pre><code>hello</code></pre>"},
		// HTML escaped inside code block
		{"```\n<div>test</div>\n```",
			"<pre><code>&lt;div&gt;test&lt;/div&gt;</code></pre>"},
	}
	for _, tt := range tests {
		got := string(fn(tt.input))
		if got != tt.want {
			t.Errorf("formatBody(%q):\n  got:  %s\n  want: %s", tt.input, got, tt.want)
		}
	}
}

func TestFuncMap_DiffBar_Zero(t *testing.T) {
	fn := funcMap["diffBar"].(func(int, int) template.HTML)
	got := fn(0, 0)
	if string(got) != "" {
		t.Errorf("expected empty, got %q", got)
	}
}

func TestFuncMap_DiffBar_AddOnly(t *testing.T) {
	fn := funcMap["diffBar"].(func(int, int) template.HTML)
	got := string(fn(5, 0))
	if !strings.Contains(got, "bar-add") {
		t.Errorf("expected bar-add, got %q", got)
	}
}

func TestFuncMap_DiffBar_Mixed(t *testing.T) {
	fn := funcMap["diffBar"].(func(int, int) template.HTML)
	got := string(fn(3, 2))
	if !strings.Contains(got, "bar-add") || !strings.Contains(got, "bar-del") {
		t.Errorf("expected both bar-add and bar-del, got %q", got)
	}
}

// ===================================================================
// Template rendering
// ===================================================================

func TestTemplateRender_UnknownTemplate(t *testing.T) {
	srv := testServer(t)
	w := httptest.NewRecorder()
	srv.tmpl.render(w, "nonexistent", nil)
	if !strings.Contains(w.Body.String(), "not found") {
		t.Error("expected 'not found' for unknown template")
	}
}

func TestLoadTemplates(t *testing.T) {
	ts, err := loadTemplates()
	if err != nil {
		t.Fatalf("loadTemplates: %v", err)
	}
	for _, name := range []string{"index", "home", "log", "commit", "refs", "error", "discussions", "discussion", "discussion_new", "login"} {
		if _, ok := ts.templates[name]; !ok {
			t.Errorf("missing template %q", name)
		}
	}
}

// ===================================================================
// Git logic: sortTreeEntries, collapseContext, mimeFromPath,
// parseDiffOutput, parseHunkHeader
// ===================================================================

func TestSortTreeEntries(t *testing.T) {
	entries := []TreeEntryInfo{
		{Name: "b.go", IsDir: false},
		{Name: "a.go", IsDir: false},
		{Name: "z-dir", IsDir: true},
		{Name: "a-dir", IsDir: true},
	}
	sortTreeEntries(entries)
	if entries[0].Name != "a-dir" || entries[1].Name != "z-dir" {
		t.Errorf("dirs not first: %v", entries)
	}
	if entries[2].Name != "a.go" || entries[3].Name != "b.go" {
		t.Errorf("files not sorted: %v", entries)
	}
}

func TestCollapseContext_Empty(t *testing.T) {
	if hunks := collapseContext(nil); hunks != nil {
		t.Errorf("expected nil, got %v", hunks)
	}
}

func TestCollapseContext_AllChanges(t *testing.T) {
	lines := []DiffLine{
		{Type: "add", Content: "a", NewNum: 1},
		{Type: "del", Content: "b", OldNum: 1},
	}
	hunks := collapseContext(lines)
	if len(hunks) != 1 {
		t.Fatalf("expected 1, got %d", len(hunks))
	}
	if len(hunks[0].Lines) != 2 {
		t.Errorf("expected 2 lines, got %d", len(hunks[0].Lines))
	}
}

func TestCollapseContext_SplitsDistantChanges(t *testing.T) {
	var lines []DiffLine
	lines = append(lines, DiffLine{Type: "add", Content: "first", NewNum: 1})
	for i := 0; i < 20; i++ {
		lines = append(lines, DiffLine{Type: "context", Content: "ctx", OldNum: i + 1, NewNum: i + 2})
	}
	lines = append(lines, DiffLine{Type: "add", Content: "second", NewNum: 22})

	hunks := collapseContext(lines)
	if len(hunks) != 2 {
		t.Errorf("expected 2 hunks, got %d", len(hunks))
	}
}

func TestCollapseContext_KeepsNearbyContext(t *testing.T) {
	var lines []DiffLine
	lines = append(lines, DiffLine{Type: "context", Content: "before", OldNum: 1, NewNum: 1})
	lines = append(lines, DiffLine{Type: "add", Content: "new", NewNum: 2})
	lines = append(lines, DiffLine{Type: "context", Content: "after", OldNum: 2, NewNum: 3})

	hunks := collapseContext(lines)
	if len(hunks) != 1 {
		t.Fatalf("expected 1 hunk, got %d", len(hunks))
	}
	if len(hunks[0].Lines) != 3 {
		t.Errorf("expected 3 lines (context around change), got %d", len(hunks[0].Lines))
	}
}

func TestMimeFromPath(t *testing.T) {
	tests := map[string]string{
		"file.go":   "text/plain; charset=utf-8",
		"file.png":  "image/png",
		"file.pdf":  "application/pdf",
		"file.css":  "text/css; charset=utf-8",
		"file.json": "application/json",
		"file.svg":  "image/svg+xml",
		"file.RS":   "text/plain; charset=utf-8",
		"noext":     "",
		"file.xyz":  "",
	}
	for path, want := range tests {
		if got := mimeFromPath(path); got != want {
			t.Errorf("mimeFromPath(%q) = %q, want %q", path, got, want)
		}
	}
}

func TestParseDiffOutput_Added(t *testing.T) {
	output := `diff --git a/file.go b/file.go
new file mode 100644
index 0000000..abc1234
--- /dev/null
+++ b/file.go
@@ -0,0 +1,3 @@
+package main
+
+func main() {}
`
	files := parseDiffOutput(output)
	if len(files) != 1 {
		t.Fatalf("expected 1, got %d", len(files))
	}
	if files[0].Status != "A" {
		t.Errorf("status: %q", files[0].Status)
	}
	if files[0].NewName != "file.go" {
		t.Errorf("name: %q", files[0].NewName)
	}
	if files[0].Stats.Added != 3 {
		t.Errorf("added: %d", files[0].Stats.Added)
	}
}

func TestParseDiffOutput_Deleted(t *testing.T) {
	output := `diff --git a/old.go b/old.go
deleted file mode 100644
index abc1234..0000000
--- a/old.go
+++ /dev/null
@@ -1,2 +0,0 @@
-package old
-
`
	files := parseDiffOutput(output)
	if len(files) != 1 {
		t.Fatalf("expected 1, got %d", len(files))
	}
	if files[0].Status != "D" {
		t.Errorf("status: %q", files[0].Status)
	}
	if files[0].Stats.Deleted != 2 {
		t.Errorf("deleted: %d", files[0].Stats.Deleted)
	}
}

func TestParseDiffOutput_Rename(t *testing.T) {
	output := `diff --git a/old.go b/new.go
rename from old.go
rename to new.go
`
	files := parseDiffOutput(output)
	if len(files) != 1 {
		t.Fatalf("expected 1, got %d", len(files))
	}
	if files[0].Status != "R" {
		t.Errorf("status: %q", files[0].Status)
	}
}

func TestParseDiffOutput_Binary(t *testing.T) {
	output := `diff --git a/image.png b/image.png
new file mode 100644
Binary files /dev/null and b/image.png differ
`
	files := parseDiffOutput(output)
	if len(files) != 1 {
		t.Fatalf("expected 1, got %d", len(files))
	}
	if !files[0].IsBinary {
		t.Error("expected binary")
	}
}

func TestParseDiffOutput_Modified(t *testing.T) {
	output := `diff --git a/file.go b/file.go
index abc..def 100644
--- a/file.go
+++ b/file.go
@@ -1,3 +1,4 @@
 package main
 
 func main() {}
+func extra() {}
`
	files := parseDiffOutput(output)
	if len(files) != 1 {
		t.Fatalf("expected 1, got %d", len(files))
	}
	if files[0].Status != "M" {
		t.Errorf("status: %q", files[0].Status)
	}
	if files[0].Stats.Added != 1 {
		t.Errorf("added: %d", files[0].Stats.Added)
	}
}

func TestParseDiffOutput_MultipleFiles(t *testing.T) {
	output := `diff --git a/a.go b/a.go
new file mode 100644
--- /dev/null
+++ b/a.go
@@ -0,0 +1 @@
+package a
diff --git a/b.go b/b.go
new file mode 100644
--- /dev/null
+++ b/b.go
@@ -0,0 +1 @@
+package b
`
	files := parseDiffOutput(output)
	if len(files) != 2 {
		t.Fatalf("expected 2, got %d", len(files))
	}
}

func TestParseDiffOutput_Empty(t *testing.T) {
	files := parseDiffOutput("")
	if len(files) != 0 {
		t.Errorf("expected 0, got %d", len(files))
	}
}

func TestParseHunkHeader(t *testing.T) {
	tests := []struct {
		input string
		want  []int
	}{
		{"@@ -1,5 +1,7 @@", []int{1, 1}},
		{"@@ -10,3 +20,5 @@ func foo()", []int{10, 20}},
		{"@@ -1 +1 @@", []int{1, 1}},
		{"no hunk", nil},
		{"@@  @@", nil},
	}
	for _, tt := range tests {
		got := parseHunkHeader(tt.input)
		if tt.want == nil {
			if got != nil {
				t.Errorf("parseHunkHeader(%q) = %v, want nil", tt.input, got)
			}
		} else {
			if got == nil || got[0] != tt.want[0] || got[1] != tt.want[1] {
				t.Errorf("parseHunkHeader(%q) = %v, want %v", tt.input, got, tt.want)
			}
		}
	}
}

// ===================================================================
// Git CLI backend (integration with real repo)
// ===================================================================

func TestGit_ResolveRef(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, err := git.resolveRef(git.getDefaultBranch())
	if err != nil {
		t.Fatalf("resolveRef: %v", err)
	}
	if len(hash) < 40 {
		t.Errorf("expected full hash, got %q", hash)
	}
}

func TestGit_ResolveRefEmpty(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, err := git.resolveRef("")
	if err != nil {
		t.Fatalf("resolveRef empty: %v", err)
	}
	if len(hash) < 40 {
		t.Errorf("expected full hash, got %q", hash)
	}
}

func TestGit_ResolveRefInvalid(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	if _, err := git.resolveRef("nonexistent"); err == nil {
		t.Error("expected error")
	}
}

func TestGit_ResolveRefAndPath(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	ref := git.getDefaultBranch()

	hash, gotRef, path, err := git.resolveRefAndPath(strings.Split(ref+"/main.go", "/"))
	if err != nil {
		t.Fatalf("resolveRefAndPath: %v", err)
	}
	if gotRef != ref {
		t.Errorf("ref: %q, want %q", gotRef, ref)
	}
	if path != "main.go" {
		t.Errorf("path: %q", path)
	}
	if len(hash) < 40 {
		t.Errorf("hash: %q", hash)
	}
}

func TestGit_ResolveRefAndPath_SlashBranch(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git

	_, ref, path, err := git.resolveRefAndPath([]string{"feature", "test", "feature.txt"})
	if err != nil {
		t.Fatalf("resolveRefAndPath: %v", err)
	}
	if ref != "feature/test" {
		t.Errorf("ref: %q", ref)
	}
	if path != "feature.txt" {
		t.Errorf("path: %q", path)
	}
}

func TestGit_ResolveRefAndPath_RefOnly(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	ref := git.getDefaultBranch()

	_, gotRef, path, err := git.resolveRefAndPath([]string{ref})
	if err != nil {
		t.Fatalf("resolveRefAndPath ref only: %v", err)
	}
	if gotRef != ref {
		t.Errorf("ref: %q", gotRef)
	}
	if path != "" {
		t.Errorf("path should be empty: %q", path)
	}
}

func TestGit_ResolveRefAndPath_Invalid(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	if _, _, _, err := git.resolveRefAndPath([]string{"no", "such", "ref"}); err == nil {
		t.Error("expected error")
	}
}

func TestGit_GetDefaultBranch(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	branch := git.getDefaultBranch()
	if branch == "" {
		t.Error("expected non-empty")
	}
	if _, err := git.resolveRef(branch); err != nil {
		t.Errorf("branch %q not resolvable: %v", branch, err)
	}
}

func TestGit_GetBranches(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	branches, err := git.getBranches()
	if err != nil {
		t.Fatalf("getBranches: %v", err)
	}
	if len(branches) < 2 {
		t.Fatalf("expected >= 2, got %d", len(branches))
	}
	names := make(map[string]bool)
	for _, b := range branches {
		names[b.Name] = true
		if b.Hash == "" || b.ShortHash == "" {
			t.Errorf("branch %q has empty hash", b.Name)
		}
		if b.IsTag {
			t.Errorf("branch %q should not be tag", b.Name)
		}
	}
	if !names["feature/test"] {
		t.Error("expected feature/test")
	}
}

func TestGit_GetTags(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	tags, err := git.getTags()
	if err != nil {
		t.Fatalf("getTags: %v", err)
	}
	if len(tags) != 1 {
		t.Fatalf("expected 1, got %d", len(tags))
	}
	if tags[0].Name != "v1.0" {
		t.Errorf("name: %q", tags[0].Name)
	}
	if !tags[0].IsTag {
		t.Error("expected IsTag")
	}
	if tags[0].Subject != "Release v1.0" {
		t.Errorf("subject: %q", tags[0].Subject)
	}
}

func TestGit_GetTree(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	entries, err := git.getTree(hash, "")
	if err != nil {
		t.Fatalf("getTree: %v", err)
	}
	if len(entries) == 0 {
		t.Fatal("expected entries")
	}
	// Dirs first.
	seenFile := false
	for _, e := range entries {
		if !e.IsDir {
			seenFile = true
		} else if seenFile {
			t.Error("dir appeared after file — not sorted")
		}
	}
}

func TestGit_GetTree_Subdir(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	entries, err := git.getTree(hash, "pkg")
	if err != nil {
		t.Fatalf("getTree pkg: %v", err)
	}
	if len(entries) != 1 || entries[0].Name != "lib.go" {
		t.Errorf("expected lib.go, got %v", entries)
	}
}

func TestGit_GetBlob(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	blob, err := git.getBlob(hash, "main.go")
	if err != nil {
		t.Fatalf("getBlob: %v", err)
	}
	if blob.Name != "main.go" {
		t.Errorf("name: %q", blob.Name)
	}
	if blob.IsBinary {
		t.Error("expected non-binary")
	}
	if !strings.Contains(blob.Content, "package main") {
		t.Error("expected content")
	}
	if blob.Size == 0 {
		t.Error("expected non-zero size")
	}
	if len(blob.Lines) == 0 {
		t.Error("expected lines")
	}
}

func TestGit_GetBlob_Nested(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	blob, err := git.getBlob(hash, "pkg/lib.go")
	if err != nil {
		t.Fatalf("getBlob: %v", err)
	}
	// Name should be the basename.
	if blob.Name != "lib.go" {
		t.Errorf("name: %q", blob.Name)
	}
}

func TestGit_GetBlob_NotFound(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())
	if _, err := git.getBlob(hash, "nonexistent.txt"); err == nil {
		t.Error("expected error")
	}
}

func TestGit_GetRawBlob(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	reader, ct, size, err := git.getRawBlob(hash, "main.go")
	if err != nil {
		t.Fatalf("getRawBlob: %v", err)
	}
	defer reader.Close()
	if ct != "text/plain; charset=utf-8" {
		t.Errorf("content-type: %q", ct)
	}
	if size == 0 {
		t.Error("expected non-zero size")
	}
	buf := make([]byte, 1024)
	n, _ := reader.Read(buf)
	if !strings.Contains(string(buf[:n]), "package main") {
		t.Error("expected content from reader")
	}
}

func TestGit_IsTreePath(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	if !git.isTreePath(hash, "") {
		t.Error("empty path should be tree")
	}
	if !git.isTreePath(hash, "pkg") {
		t.Error("pkg should be tree")
	}
	if git.isTreePath(hash, "main.go") {
		t.Error("main.go should not be tree")
	}
	if git.isTreePath(hash, "nonexistent") {
		t.Error("nonexistent should not be tree")
	}
}

func TestGit_BuildTreeNodes(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	nodes := git.buildTreeNodes(hash, "")
	if len(nodes) == 0 {
		t.Fatal("expected nodes")
	}
	for _, n := range nodes {
		if n.Depth != 0 {
			t.Errorf("expected depth 0 for %q, got %d", n.Name, n.Depth)
		}
		if n.IsOpen {
			t.Errorf("expected not open: %q", n.Name)
		}
	}
}

func TestGit_BuildTreeNodes_ActiveFile(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	nodes := git.buildTreeNodes(hash, "pkg/lib.go")
	var pkgOpen, libActive bool
	for _, n := range nodes {
		if n.Name == "pkg" && n.IsOpen {
			pkgOpen = true
		}
		if n.Name == "lib.go" && n.IsActive && n.Depth == 1 {
			libActive = true
		}
	}
	if !pkgOpen {
		t.Error("pkg should be open")
	}
	if !libActive {
		t.Error("lib.go should be active at depth 1")
	}
}

func TestGit_BuildTreeNodes_ActiveDir(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	nodes := git.buildTreeNodes(hash, "pkg")
	var found bool
	for _, n := range nodes {
		if n.Name == "pkg" && n.IsActive && n.IsOpen {
			found = true
		}
	}
	if !found {
		t.Error("pkg should be active and open")
	}
}

func TestGit_GetReadme(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	readme := git.getReadme(hash, "")
	if readme == nil {
		t.Fatal("expected README")
	}
	if readme.Name != "README.md" {
		t.Errorf("name: %q", readme.Name)
	}
	if !strings.Contains(readme.Content, "Hello world") {
		t.Error("expected content")
	}
}

func TestGit_GetReadme_NotFound(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())
	if readme := git.getReadme(hash, "pkg"); readme != nil {
		t.Errorf("expected nil for dir without README, got %+v", readme)
	}
}

func TestGit_GetLog(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	commits, hasMore, err := git.getLog(hash, 0, 50)
	if err != nil {
		t.Fatalf("getLog: %v", err)
	}
	if len(commits) < 2 {
		t.Fatalf("expected >= 2, got %d", len(commits))
	}
	if hasMore {
		t.Error("should not have more")
	}
	if commits[0].Subject != "Add extra file" {
		t.Errorf("first: %q", commits[0].Subject)
	}
	for _, c := range commits {
		if c.Hash == "" || c.ShortHash == "" || c.Author == "" {
			t.Errorf("empty fields: %+v", c)
		}
	}
}

func TestGit_GetLog_Pagination(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	commits, hasMore, _ := git.getLog(hash, 0, 1)
	if len(commits) != 1 {
		t.Fatalf("expected 1, got %d", len(commits))
	}
	if !hasMore {
		t.Error("expected hasMore")
	}
}

func TestGit_GetCommit(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	commit, err := git.getCommit(hash)
	if err != nil {
		t.Fatalf("getCommit: %v", err)
	}
	if commit.Hash != hash {
		t.Errorf("hash mismatch")
	}
	if commit.Author != "Test User" {
		t.Errorf("author: %q", commit.Author)
	}
	if commit.AuthorEmail != "test@example.com" {
		t.Errorf("email: %q", commit.AuthorEmail)
	}
	if commit.AuthorDate.IsZero() {
		t.Error("zero date")
	}
	if len(commit.Parents) == 0 {
		t.Error("expected parents")
	}
}

func TestGit_GetCommit_RootHasNoParents(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash := initialHash(t, srv)
	commit, err := git.getCommit(hash)
	if err != nil {
		t.Fatalf("getCommit: %v", err)
	}
	if len(commit.Parents) != 0 {
		t.Errorf("root commit should have 0 parents, got %d", len(commit.Parents))
	}
}

func TestGit_GetCommit_Invalid(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	if _, err := git.getCommit("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"); err == nil {
		t.Error("expected error")
	}
}

func TestGit_GetDiff(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash, _ := git.resolveRef(git.getDefaultBranch())

	files, err := git.getDiff(hash)
	if err != nil {
		t.Fatalf("getDiff: %v", err)
	}
	if len(files) == 0 {
		t.Fatal("expected files")
	}
	found := false
	for _, f := range files {
		if f.NewName == "extra.txt" {
			found = true
			if f.Status != "A" {
				t.Errorf("status: %q", f.Status)
			}
		}
	}
	if !found {
		t.Error("expected extra.txt")
	}
}

func TestGit_GetDiff_RootCommit(t *testing.T) {
	srv := testServer(t)
	git := srv.repos["testrepo"].Git
	hash := initialHash(t, srv)

	files, err := git.getDiff(hash)
	if err != nil {
		t.Fatalf("getDiff root: %v", err)
	}
	if len(files) == 0 {
		t.Fatal("expected files")
	}
	names := make(map[string]bool)
	for _, f := range files {
		names[f.NewName] = true
	}
	for _, want := range []string{"README.md", "main.go"} {
		if !names[want] {
			t.Errorf("expected %q", want)
		}
	}
}

// ===================================================================
// parseRefLines / parseTagRefLines
// ===================================================================

func TestParseRefLines(t *testing.T) {
	input := "main\tabc123\tabc12345\tSubject\tAuthor\t2024-01-15T10:00:00+00:00\n"
	refs := parseRefLines(input, false)
	if len(refs) != 1 {
		t.Fatalf("expected 1, got %d", len(refs))
	}
	if refs[0].Name != "main" || refs[0].IsTag {
		t.Errorf("got %+v", refs[0])
	}
}

func TestParseRefLines_TruncatesShortHash(t *testing.T) {
	input := "main\tabc123456789\tabc123456789\tSub\tAuth\t2024-01-15T10:00:00+00:00\n"
	refs := parseRefLines(input, false)
	if len(refs[0].ShortHash) != 8 {
		t.Errorf("short hash not truncated: %q", refs[0].ShortHash)
	}
}

func TestParseRefLines_Empty(t *testing.T) {
	if refs := parseRefLines("", false); len(refs) != 0 {
		t.Errorf("expected 0, got %d", len(refs))
	}
}

func TestParseRefLines_Malformed(t *testing.T) {
	if refs := parseRefLines("only\ttwo\tfields\n", false); len(refs) != 0 {
		t.Errorf("expected 0, got %d", len(refs))
	}
}

func TestParseTagRefLines(t *testing.T) {
	input := "v1.0\tabc123\tabc12345\t\tRelease\tAuthor\t2024-01-15T10:00:00+00:00\n"
	refs := parseTagRefLines(input)
	if len(refs) != 1 {
		t.Fatalf("expected 1, got %d", len(refs))
	}
	if !refs[0].IsTag || refs[0].Name != "v1.0" {
		t.Errorf("got %+v", refs[0])
	}
}

func TestParseTagRefLines_Annotated(t *testing.T) {
	input := "v2.0\ttagobj1234567890\ttagobj12\tcommitabcdef1234567890\tRelease\tAuth\t2024-01-15T10:00:00+00:00\n"
	refs := parseTagRefLines(input)
	if len(refs) != 1 {
		t.Fatalf("expected 1, got %d", len(refs))
	}
	if refs[0].Hash != "commitabcdef1234567890" {
		t.Errorf("hash should be deref: %q", refs[0].Hash)
	}
	if refs[0].ShortHash != "commitab" {
		t.Errorf("short hash: %q", refs[0].ShortHash)
	}
}

func TestParseTagRefLines_Empty(t *testing.T) {
	if refs := parseTagRefLines(""); len(refs) != 0 {
		t.Errorf("expected 0, got %d", len(refs))
	}
}

// ===================================================================
// newPageData
// ===================================================================

func TestNewPageData_NoRepo(t *testing.T) {
	srv := testServer(t)
	req := httptest.NewRequest(http.MethodGet, "/", nil)
	pd := srv.newPageData(req, nil, "home", "main")
	if pd.SiteTitle != "Test Forge" {
		t.Errorf("title: %q", pd.SiteTitle)
	}
	if pd.Repo != "" {
		t.Errorf("repo: %q", pd.Repo)
	}
	if pd.Section != "home" {
		t.Errorf("section: %q", pd.Section)
	}
	if pd.Ref != "main" {
		t.Errorf("ref: %q", pd.Ref)
	}
	if pd.SiteDescription != "test site description" {
		t.Errorf("site description: %q", pd.SiteDescription)
	}
}

func TestNewPageData_WithRepo(t *testing.T) {
	srv := testServer(t)
	req := httptest.NewRequest(http.MethodGet, "/testrepo/", nil)
	pd := srv.newPageData(req, srv.repos["testrepo"], "home", "main")
	if pd.Repo != "testrepo" {
		t.Errorf("repo: %q", pd.Repo)
	}
	if pd.Description != "A test repository" {
		t.Errorf("description: %q", pd.Description)
	}
}

func TestNewPageData_WithSession(t *testing.T) {
	srv := testServer(t)
	upsertAvatar(srv.db, "alice", "https://example.com/av.png")
	req := httptest.NewRequest(http.MethodGet, "/", nil)
	req.AddCookie(&http.Cookie{Name: sessionCookieName, Value: signSession("alice")})
	pd := srv.newPageData(req, nil, "", "")
	if pd.Handle != "alice" {
		t.Errorf("handle: %q", pd.Handle)
	}
	if pd.Avatar != "https://example.com/av.png" {
		t.Errorf("avatar: %q", pd.Avatar)
	}
}

func TestNewPageData_NoSession(t *testing.T) {
	srv := testServer(t)
	req := httptest.NewRequest(http.MethodGet, "/", nil)
	pd := srv.newPageData(req, nil, "", "")
	if pd.Handle != "" || pd.Avatar != "" {
		t.Errorf("expected empty handle/avatar, got %q/%q", pd.Handle, pd.Avatar)
	}
}