package main

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"
	"testing"

	"git.unkin.net/unkin/agent-tools/internal/agent"
)

// fixture is a bare origin plus a source checkout named "repo" and a worktree
// root, wired so managedWorktrees() finds the worktrees created here.
type fixture struct {
	root   string
	bare   string
	srcDir string
	wtRoot string
}

func git(t *testing.T, dir string, args ...string) string {
	t.Helper()
	cmd := exec.Command("git", args...)
	cmd.Dir = dir
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("git %s (in %s): %v: %s", strings.Join(args, " "), dir, err, out)
	}
	return strings.TrimSpace(string(out))
}

func newFixture(t *testing.T) *fixture {
	t.Helper()
	root := t.TempDir()
	f := &fixture{
		root:   root,
		bare:   filepath.Join(root, "origin.git"),
		srcDir: filepath.Join(root, "src", "repo"),
		wtRoot: filepath.Join(root, "worktrees"),
	}
	if err := os.MkdirAll(filepath.Join(root, "src"), 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.MkdirAll(f.wtRoot, 0o755); err != nil {
		t.Fatal(err)
	}
	git(t, root, "init", "--bare", "-b", "main", f.bare)

	seed := filepath.Join(root, "seed")
	git(t, root, "init", "-b", "main", seed)
	identity(t, seed)
	writeCommit(t, seed, "README.md", "hi\n", "init")
	git(t, seed, "remote", "add", "origin", f.bare)
	git(t, seed, "push", "-u", "origin", "main")

	git(t, filepath.Join(root, "src"), "clone", f.bare, f.srcDir)
	identity(t, f.srcDir)

	t.Setenv("AGENTWS_ROOT", f.wtRoot)
	t.Setenv("AGENTWS_SRC_ROOT", filepath.Join(root, "src"))
	t.Setenv("AGENTWS_OWNER", "unkin")
	return f
}

func identity(t *testing.T, dir string) {
	t.Helper()
	git(t, dir, "config", "user.email", "test@example.com")
	git(t, dir, "config", "user.name", "Test")
}

func writeCommit(t *testing.T, dir, name, content, msg string) {
	t.Helper()
	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o644); err != nil {
		t.Fatal(err)
	}
	git(t, dir, "add", ".")
	git(t, dir, "commit", "-m", msg)
}

// addWorktree creates a managed worktree for branch and returns its path.
func (f *fixture) addWorktree(t *testing.T, branch string) string {
	t.Helper()
	path := filepath.Join(f.wtRoot, agent.WorktreeDirName("repo", branch))
	git(t, f.srcDir, "worktree", "add", path, "-b", branch, "origin/main")
	identity(t, path)
	return path
}

// landUpstream commits content on origin's main, mimicking a squash merge: the
// same patch arrives upstream under a different SHA.
func (f *fixture) landUpstream(t *testing.T, name, content, msg string) {
	t.Helper()
	seed := filepath.Join(f.root, "seed")
	git(t, seed, "pull", "--ff-only", "origin", "main")
	writeCommit(t, seed, name, content, msg)
	git(t, seed, "push", "origin", "main")
}

// fakeGitea serves the pulls listing for unkin/repo with the given PR bodies.
func fakeGitea(t *testing.T, prs ...map[string]any) *httptest.Server {
	t.Helper()
	mux := http.NewServeMux()
	mux.HandleFunc("/api/v1/repos/unkin/repo/pulls", func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Query().Get("page") != "1" {
			_, _ = w.Write([]byte("[]"))
			return
		}
		body, err := json.Marshal(prs)
		if err != nil {
			t.Errorf("marshal PRs: %v", err)
		}
		_, _ = w.Write(body)
	})
	srv := httptest.NewServer(mux)
	t.Cleanup(srv.Close)
	return srv
}

func client(srv *httptest.Server) prLister {
	return &agent.GiteaClient{BaseURL: srv.URL, HTTP: srv.Client()}
}

// mergedPR mimics Gitea after a merge: the branch is deleted, so head.ref
// becomes refs/pull/<n>/head and only head.label still names the branch.
func mergedPR(number int, branch string) map[string]any {
	return map[string]any{
		"number": number,
		"state":  "closed",
		"merged": true,
		"head": map[string]any{
			"ref":   "refs/pull/" + strconv.Itoa(number) + "/head",
			"label": branch,
		},
	}
}

func openPR(number int, branch string) map[string]any {
	return map[string]any{
		"number": number,
		"state":  "open",
		"merged": false,
		"head":   map[string]any{"ref": branch, "label": branch},
	}
}

func closedPR(number int, branch string) map[string]any {
	return map[string]any{
		"number": number,
		"state":  "closed",
		"merged": false,
		"head":   map[string]any{"ref": branch, "label": branch},
	}
}

func run(t *testing.T, prs prLister, apply, keepBranches bool) string {
	t.Helper()
	var out bytes.Buffer
	if err := runPrune(&out, prs, apply, keepBranches); err != nil {
		t.Fatalf("runPrune: %v\n%s", err, out.String())
	}
	return out.String()
}

func lineFor(t *testing.T, out, branch string) string {
	t.Helper()
	for _, line := range strings.Split(out, "\n") {
		if strings.Contains(line, " "+branch+" ") {
			return line
		}
	}
	t.Fatalf("no line for branch %q in:\n%s", branch, out)
	return ""
}

func assertVerdict(t *testing.T, out, branch, verdict, reason string) {
	t.Helper()
	line := lineFor(t, out, branch)
	fields := strings.Fields(line)
	if len(fields) < 3 || fields[2] != verdict {
		t.Errorf("branch %s: verdict line %q, want verdict %q", branch, line, verdict)
	}
	if reason != "" && !strings.Contains(line, reason) {
		t.Errorf("branch %s: line %q, want reason containing %q", branch, line, reason)
	}
}

func exists(path string) bool {
	_, err := os.Stat(path)
	return err == nil
}

// A merged PR's branch is deleted on merge, so its head.ref reads
// refs/pull/<n>/head; classification must still see the merge (via head.label)
// and remove the branch, not fall through to "no PR".
func TestPruneMergedPRWithDeletedBranch(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/merged")
	writeCommit(t, wt, "m.txt", "m\n", "work")

	srv := fakeGitea(t, mergedPR(3, "benvin/merged"))
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/merged", verdictRemoveBranch, "PR merged #3")

	if exists(wt) {
		t.Errorf("worktree %s should have been removed", wt)
	}
	if agent.GitBranchExists(f.srcDir, "benvin/merged") {
		t.Error("branch of a merged PR should be deleted")
	}
}

// The same PR without head.label: matching falls back to head.ref, which no
// longer names the branch, so prune must not guess it is merged — the worktree
// goes but the branch stays.
func TestPruneMergedPRWithoutLabelKeepsBranch(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/merged")
	writeCommit(t, wt, "m.txt", "m\n", "work")

	pr := mergedPR(3, "benvin/merged")
	pr["head"].(map[string]any)["label"] = ""
	srv := fakeGitea(t, pr)
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/merged", verdictRemove, "no PR")

	if !agent.GitBranchExists(f.srcDir, "benvin/merged") {
		t.Error("branch must survive when the PR could not be matched")
	}
}

func TestPruneContainedBranch(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/contained")

	srv := fakeGitea(t)
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/contained", verdictRemoveBranch, "contained in origin/main")

	if exists(wt) {
		t.Error("contained worktree should have been removed")
	}
	if agent.GitBranchExists(f.srcDir, "benvin/contained") {
		t.Error("contained branch should be deleted")
	}
}

// Squash-merged work keeps a local SHA that is not upstream, so only the
// patch-equivalence check proves it landed.
func TestPruneCherryCleanBranch(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/squashed")
	writeCommit(t, wt, "s.txt", "same\n", "add s")
	f.landUpstream(t, "s.txt", "same\n", "squashed s")

	srv := fakeGitea(t)
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/squashed", verdictRemoveBranch, "cherry-clean")

	if agent.GitBranchExists(f.srcDir, "benvin/squashed") {
		t.Error("cherry-clean branch should be deleted")
	}
}

// Uncommitted work outranks every other signal, including a branch that is
// otherwise fully contained upstream.
func TestPruneNeverTouchesDirtyWorktree(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/dirty")
	if err := os.WriteFile(filepath.Join(wt, "wip.txt"), []byte("wip\n"), 0o644); err != nil {
		t.Fatal(err)
	}

	srv := fakeGitea(t, mergedPR(4, "benvin/dirty"))
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/dirty", verdictKeep, "dirty")

	if !exists(wt) {
		t.Error("dirty worktree must not be removed")
	}
	if !agent.GitBranchExists(f.srcDir, "benvin/dirty") {
		t.Error("dirty worktree's branch must survive")
	}
}

// An open PR is kept even when its commits are already upstream.
func TestPruneKeepsOpenPR(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/open")

	srv := fakeGitea(t, openPR(5, "benvin/open"))
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/open", verdictKeep, "PR open #5")

	if !exists(wt) {
		t.Error("worktree with an open PR must not be removed")
	}
	if !agent.GitBranchExists(f.srcDir, "benvin/open") {
		t.Error("branch with an open PR must not be deleted")
	}
}

// Closed-unmerged with the branch still on origin: the work is not lost, so the
// local branch goes too.
func TestPruneClosedPRWithBranchOnOrigin(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/closed")
	writeCommit(t, wt, "c.txt", "c\n", "work")
	git(t, wt, "push", "origin", "benvin/closed")

	srv := fakeGitea(t, closedPR(6, "benvin/closed"))
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/closed", verdictRemoveBranch, "PR closed #6, branch on origin")

	if exists(wt) {
		t.Error("worktree should have been removed")
	}
	if agent.GitBranchExists(f.srcDir, "benvin/closed") {
		t.Error("branch should be deleted while origin still has it")
	}
}

// Closed-unmerged with nothing on origin: the commits exist only here, so the
// branch is kept and only the worktree goes.
func TestPruneClosedPRWithBranchGone(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/orphan")
	writeCommit(t, wt, "o.txt", "o\n", "work")

	srv := fakeGitea(t, closedPR(7, "benvin/orphan"))
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/orphan", verdictRemove, "PR closed #7, branch gone")

	if exists(wt) {
		t.Error("worktree should have been removed")
	}
	if !agent.GitBranchExists(f.srcDir, "benvin/orphan") {
		t.Error("branch must survive when origin does not have the commits")
	}
}

func TestPruneNoPRKeepsBranch(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/unpushed")
	writeCommit(t, wt, "u.txt", "u\n", "work")

	srv := fakeGitea(t)
	out := run(t, client(srv), true, false)
	assertVerdict(t, out, "benvin/unpushed", verdictRemove, "no PR")

	if exists(wt) {
		t.Error("worktree should have been removed")
	}
	if !agent.GitBranchExists(f.srcDir, "benvin/unpushed") {
		t.Error("branch with unproven work must survive")
	}
}

// The default run reports and changes nothing.
func TestPruneDryRunChangesNothing(t *testing.T) {
	f := newFixture(t)
	contained := f.addWorktree(t, "benvin/contained")
	merged := f.addWorktree(t, "benvin/merged")
	writeCommit(t, merged, "m.txt", "m\n", "work")

	srv := fakeGitea(t, mergedPR(8, "benvin/merged"))
	out := run(t, client(srv), false, false)

	if !strings.Contains(out, "dry run") {
		t.Errorf("dry-run output should say so:\n%s", out)
	}
	assertVerdict(t, out, "benvin/contained", verdictRemoveBranch, "contained")
	assertVerdict(t, out, "benvin/merged", verdictRemoveBranch, "PR merged #8")
	if !exists(contained) || !exists(merged) {
		t.Error("dry run must not remove worktrees")
	}
	if !agent.GitBranchExists(f.srcDir, "benvin/contained") || !agent.GitBranchExists(f.srcDir, "benvin/merged") {
		t.Error("dry run must not delete branches")
	}
}

// --keep-branches removes worktrees but leaves every branch alone.
func TestPruneKeepBranches(t *testing.T) {
	f := newFixture(t)
	wt := f.addWorktree(t, "benvin/contained")

	srv := fakeGitea(t)
	out := run(t, client(srv), true, true)
	assertVerdict(t, out, "benvin/contained", verdictRemoveBranch, "contained")

	if exists(wt) {
		t.Error("worktree should have been removed")
	}
	if !agent.GitBranchExists(f.srcDir, "benvin/contained") {
		t.Error("--keep-branches must not delete the branch")
	}
}

// With Gitea unreachable prune falls back to the git signals: provably-upstream
// work is still cleaned up, and anything unproven keeps its branch.
func TestPruneDegradesWhenGiteaUnreachable(t *testing.T) {
	f := newFixture(t)
	contained := f.addWorktree(t, "benvin/contained")
	unproven := f.addWorktree(t, "benvin/unproven")
	writeCommit(t, unproven, "u.txt", "u\n", "work")

	dead := httptest.NewServer(http.NewServeMux())
	c := &agent.GiteaClient{BaseURL: dead.URL, HTTP: dead.Client()}
	dead.Close()

	out := run(t, c, true, false)
	if !strings.Contains(out, "git signals only") {
		t.Errorf("output should note the Gitea failure:\n%s", out)
	}
	assertVerdict(t, out, "benvin/contained", verdictRemoveBranch, "contained")
	assertVerdict(t, out, "benvin/unproven", verdictRemove, "PR state unknown")

	if exists(contained) || exists(unproven) {
		t.Error("both worktrees should have been removed")
	}
	if agent.GitBranchExists(f.srcDir, "benvin/contained") {
		t.Error("contained branch is safe to delete without Gitea")
	}
	if !agent.GitBranchExists(f.srcDir, "benvin/unproven") {
		t.Error("unproven branch must survive an unreachable Gitea")
	}
}

func TestPruneNoWorktrees(t *testing.T) {
	newFixture(t)
	srv := fakeGitea(t)
	if out := run(t, client(srv), true, false); !strings.Contains(out, "no managed worktrees") {
		t.Errorf("output = %q", out)
	}
}

// Managed repos are not all under AGENTWS_OWNER, so the Gitea path comes from
// origin's URL; a non-Gitea remote falls back to the configured owner.
func TestRepoPathFollowsOrigin(t *testing.T) {
	t.Setenv("AGENTWS_OWNER", "unkin")
	dir := t.TempDir()
	git(t, dir, "init", "-b", "main", ".")
	git(t, dir, "remote", "add", "origin", "https://git.unkin.net/unkinben/dotfiles.git")
	if got := repoPath(dir, "dotfiles"); got != "unkinben/dotfiles" {
		t.Errorf("repoPath = %q, want unkinben/dotfiles", got)
	}
	git(t, dir, "remote", "set-url", "origin", filepath.Join(dir, "origin.git"))
	if got := repoPath(dir, "dotfiles"); got != "unkin/dotfiles" {
		t.Errorf("repoPath for a local remote = %q, want unkin/dotfiles", got)
	}
}