package gitrepo

import (
	"context"
	"errors"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"syscall"
	"testing"
	"time"
)

func TestResolveAndHoldTagRef(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	ctx := context.Background()
	bare, work := testRepo(t)
	sha := gitSHA(t, bare, "HEAD")
	gitOK(t, bare, "tag", "lite", sha)
	gitOK(t, bare, "tag", "-a", "ann", sha, "-m", "notitie")

	lite, err := ResolveTag(ctx, "git", bare, "lite")
	if err != nil {
		t.Fatal(err)
	}
	if lite.ObjectOID != sha || lite.CommitOID != sha || lite.Ref != "refs/tags/lite" {
		t.Fatalf("lightweight: %+v", lite)
	}
	ann, err := ResolveTag(ctx, "git", bare, "ann")
	if err != nil {
		t.Fatal(err)
	}
	if ann.ObjectOID == ann.CommitOID || ann.CommitOID != sha {
		t.Fatalf("annotated: %+v", ann)
	}
	if _, err := ResolveTag(ctx, "git", bare, "weg"); !errors.Is(err, ErrTagMissing) {
		t.Fatalf("ontbrekend: %v", err)
	}
	gitOK(t, bare, "symbolic-ref", "refs/tags/sym", "refs/heads/master")
	if _, err := ResolveTag(ctx, "git", bare, "sym"); !errors.Is(err, ErrTagSymbolic) {
		t.Fatalf("symbolisch: %v", err)
	}
	tree := gitSHA(t, bare, "HEAD^{tree}")
	gitOK(t, bare, "update-ref", "refs/tags/boom", tree)
	if _, err := ResolveTag(ctx, "git", bare, "boom"); !errors.Is(err, ErrTagNotCommit) {
		t.Fatalf("boom: %v", err)
	}

	hold, err := HoldTagRef(ctx, "git", bare, "lite", lite.ObjectOID)
	if err != nil {
		t.Fatal(err)
	}
	if err := exec.Command("git", "-C", bare, "update-ref", "refs/heads/side", sha).Run(); err != nil {
		t.Fatalf("andere ref: %v", err)
	}
	del := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/lite")
	if err := del.Run(); err == nil {
		t.Fatal("delete moest de lock zien")
	}
	if got := gitSHA(t, bare, "refs/tags/lite"); got != sha {
		t.Fatalf("tag veranderde onder de lock: %s", got)
	}
	if err := hold.Release(); err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(filepath.Join(bare, "refs", "tags", "lite.lock")); !os.IsNotExist(err) {
		t.Fatalf("lock bleef na abort: %v", err)
	}
	if err := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/lite").Run(); err != nil {
		t.Fatalf("delete na abort: %v", err)
	}
	gitOK(t, bare, "tag", "lite", sha)

	moved := commitNew(t, bare, sha)
	if _, err := HoldTagRef(ctx, "git", bare, "lite", moved); !errors.Is(err, ErrTagMoved) {
		t.Fatalf("verkeerde oid: %v", err)
	}
	if got := gitSHA(t, bare, "refs/tags/lite"); got != sha {
		t.Fatalf("verify mocht de tag niet schrijven: %s", got)
	}

	gitOK(t, bare, "update-ref", "-d", "refs/tags/sym")
	gitOK(t, bare, "update-ref", "-d", "refs/tags/boom")
	gitOK(t, bare, "pack-refs", "--all")
	packed, err := os.ReadFile(filepath.Join(bare, "packed-refs"))
	if err != nil || !strings.Contains(string(packed), "refs/tags/ann") {
		t.Fatalf("packed-refs: %v %s", err, packed)
	}
	hold, err = HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
	if err != nil {
		t.Fatal(err)
	}
	if err := exec.Command("git", "-C", bare, "update-ref", "-d", "refs/tags/ann").Run(); err == nil {
		t.Fatal("packed delete moest falen")
	}
	if err := hold.Release(); err != nil {
		t.Fatal(err)
	}
	if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
		t.Fatalf("annotated object veranderde: %s", got)
	}

	// Tweede lock wacht tot de eerste abort, en krijgt hem dan.
	first, err := HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
	if err != nil {
		t.Fatal(err)
	}
	gotHold := make(chan error, 1)
	go func() {
		second, err := HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
		if err != nil {
			gotHold <- err
			return
		}
		gotHold <- second.Release()
	}()
	time.Sleep(40 * time.Millisecond)
	select {
	case err := <-gotHold:
		t.Fatalf("tweede lock was te vroeg: %v", err)
	default:
	}
	if err := first.Release(); err != nil {
		t.Fatal(err)
	}
	select {
	case err := <-gotHold:
		if err != nil {
			t.Fatal(err)
		}
	case <-time.After(3 * time.Second):
		t.Fatal("tweede lock kwam niet vrij")
	}

	// receive-pack kan de ref niet verplaatsen zolang prepare vastzit.
	gitOK(t, work, "fetch", "origin", "tag", "ann")
	if err := os.WriteFile(filepath.Join(work, "f"), []byte("b\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	gitOK(t, work, "add", "f")
	gitOK(t, work, "commit", "-qm", "verder")
	hold, err = HoldTagRef(ctx, "git", bare, "ann", ann.ObjectOID)
	if err != nil {
		t.Fatal(err)
	}
	push := exec.Command("git", "-C", work, "push", "origin", ":refs/tags/ann")
	if err := push.Run(); err == nil {
		t.Fatal("receive-pack delete moest falen")
	}
	if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
		t.Fatalf("tijdens push: %s", got)
	}
	force := exec.Command("git", "-C", work, "push", "--force", "origin", "HEAD:refs/tags/ann")
	if err := force.Run(); err == nil {
		t.Fatal("receive-pack force moest falen")
	}
	if got := gitSHA(t, bare, "refs/tags/ann"); got != ann.ObjectOID {
		t.Fatalf("na force: %s", got)
	}
	if err := hold.Release(); err != nil {
		t.Fatal(err)
	}
	if err := exec.Command("git", "-C", work, "push", "origin", ":refs/tags/ann").Run(); err != nil {
		t.Fatalf("delete na release: %v", err)
	}
}

func TestTagRefKillDoesNotDeleteLockfile(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	bare, _ := testRepo(t)
	sha := gitSHA(t, bare, "HEAD")
	gitOK(t, bare, "tag", "v1", sha)
	hold, err := HoldTagRef(context.Background(), "git", bare, "v1", sha)
	if err != nil {
		t.Fatal(err)
	}
	pid := hold.inner.cmd.Process.Pid
	_ = syscall.Kill(pid, syscall.SIGKILL)
	_ = hold.Release()
	if _, err := os.Stat(filepath.Join(bare, "refs", "tags", "v1.lock")); err != nil {
		t.Fatalf("SIGKILL laat de lock van git staan, die ruimen we niet zelf: %v", err)
	}
}

func TestTagRefStuckProcessExits(t *testing.T) {
	old := refHoldReplyTimeout
	refHoldReplyTimeout = 200 * time.Millisecond
	t.Cleanup(func() { refHoldReplyTimeout = old })
	pidfile := filepath.Join(t.TempDir(), "pid")
	script := filepath.Join(t.TempDir(), "git")
	body := "#!/bin/sh\necho $$ > " + quoteSh(pidfile) + "\nexec sleep 30\n"
	if err := os.WriteFile(script, []byte(body), 0o755); err != nil {
		t.Fatal(err)
	}
	bare := t.TempDir()
	_, err := HoldTagRef(context.Background(), script, bare, "v1", strings.Repeat("a", 40))
	if err == nil {
		t.Fatal("vastgelopen git moest falen")
	}
	raw, err := os.ReadFile(pidfile)
	if err != nil {
		t.Fatal(err)
	}
	pid := strings.TrimSpace(string(raw))
	if err := exec.Command("ps", "-p", pid).Run(); err == nil {
		t.Fatalf("proces %s leeft nog", pid)
	}
}

func testRepo(t *testing.T) (bare, work string) {
	t.Helper()
	bare = filepath.Join(t.TempDir(), "repo.git")
	if err := Init("git", bare, "master", "/bin/true"); err != nil {
		t.Fatal(err)
	}
	work = t.TempDir()
	gitOK(t, work, "init", "-q", "-b", "master")
	if err := os.WriteFile(filepath.Join(work, "f"), []byte("a\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	gitOK(t, work, "add", "f")
	gitOK(t, work, "commit", "-qm", "init")
	gitOK(t, work, "remote", "add", "origin", bare)
	gitOK(t, work, "push", "-q", "origin", "master")
	return bare, work
}

func gitOK(t *testing.T, dir string, args ...string) {
	t.Helper()
	cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
	cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x")
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("git %v: %v %s", args, err, out)
	}
}

func gitSHA(t *testing.T, dir, rev string) string {
	t.Helper()
	cmd := exec.Command("git", "-C", dir, "rev-parse", "--verify", rev)
	out, err := cmd.Output()
	if err != nil {
		t.Fatalf("rev-parse %s: %v", rev, err)
	}
	return strings.TrimSpace(string(out))
}

func commitNew(t *testing.T, bare, parent string) string {
	t.Helper()
	tree := gitSHA(t, bare, parent+"^{tree}")
	cmd := exec.Command("git", "-C", bare, "commit-tree", tree, "-p", parent, "-m", "verder")
	cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@x", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@x")
	out, err := cmd.Output()
	if err != nil {
		t.Fatal(err)
	}
	return strings.TrimSpace(string(out))
}

func quoteSh(s string) string {
	return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
}
