package gitrepo

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

func TestParsePatchKinds(t *testing.T) {
	raw := "" +
		"diff --git a/keep.go b/keep.go\n" +
		"index 111..222 100644\n" +
		"--- a/keep.go\n" +
		"+++ b/keep.go\n" +
		"@@ -1,2 +1,3 @@\n" +
		" package p\n" +
		"-func old() {}\n" +
		"+func extra() {}\n" +
		" \n" +
		"diff --git a/gone.txt b/gone.txt\n" +
		"deleted file mode 100644\n" +
		"--- a/gone.txt\n" +
		"+++ /dev/null\n" +
		"@@ -1 +0,0 @@\n" +
		"-weg\n" +
		"diff --git \"a/oude naam.txt\" \"b/nieuwe naam.txt\"\n" +
		"similarity index 90%\n" +
		"rename from oude naam.txt\n" +
		"rename to nieuwe naam.txt\n" +
		"--- \"a/oude naam.txt\"\n" +
		"+++ \"b/nieuwe naam.txt\"\n" +
		"@@ -1 +1 @@\n" +
		"-oud\n" +
		"+nieuw\n" +
		"diff --git a/plaatje.bin b/plaatje.bin\n" +
		"new file mode 100644\n" +
		"index 0000000..abc\n" +
		"Binary files /dev/null and b/plaatje.bin differ\n"
	files := ParsePatch(raw)
	if len(files) != 4 {
		t.Fatalf("bestanden: %+v", files)
	}
	if files[0].Status != "modified" || files[0].Added != 1 || files[0].Deleted != 1 || files[0].Path != "keep.go" {
		t.Fatalf("wijziging: %+v", files[0])
	}
	if files[0].Lines[2].Kind != "del" || files[0].Lines[2].Old != 2 || files[0].Lines[3].Kind != "add" || files[0].Lines[3].New != 2 {
		t.Fatalf("regelnummers: %+v", files[0].Lines)
	}
	if files[1].Status != "deleted" || files[1].Path != "gone.txt" || files[1].Deleted != 1 {
		t.Fatalf("verwijderd: %+v", files[1])
	}
	if files[2].Status != "renamed" || files[2].OldPath != "oude naam.txt" || files[2].Path != "nieuwe naam.txt" {
		t.Fatalf("hernoemd: %+v", files[2])
	}
	if !files[3].Binary || files[3].Status != "added" || len(files[3].Lines) != 0 || files[3].Path != "plaatje.bin" {
		t.Fatalf("binair: %+v", files[3])
	}
}

func TestCommitPatchHistory(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	dir := t.TempDir()
	git := func(args ...string) {
		t.Helper()
		cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
		cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=tim", "GIT_AUTHOR_EMAIL=tim@example.com", "GIT_COMMITTER_NAME=tim", "GIT_COMMITTER_EMAIL=tim@example.com")
		if out, err := cmd.CombinedOutput(); err != nil {
			t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
		}
	}
	git("init", "-b", "master")
	git("config", "commit.gpgsign", "false")
	write := func(name, body string) {
		t.Helper()
		path := filepath.Join(dir, filepath.FromSlash(name))
		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
			t.Fatal(err)
		}
		if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
			t.Fatal(err)
		}
	}
	write("a.txt", "alpha\n")
	write("b.txt", "beta\n")
	write("keep.go", "package p\n\nfunc keep() {}\n")
	git("add", ".")
	git("commit", "-m", "begin")
	root := rev(t, dir)

	ctx := context.Background()
	parents, files, err := CommitPatch(ctx, "git", dir, root)
	if err != nil {
		t.Fatal(err)
	}
	if len(parents) != 0 || len(files) != 3 {
		t.Fatalf("root parents=%v files=%d", parents, len(files))
	}
	for _, f := range files {
		if f.Status != "added" {
			t.Fatalf("rootbestand: %+v", f)
		}
	}

	write("keep.go", "package p\n\nfunc keep() {}\nfunc extra() {}\n")
	if err := os.Remove(filepath.Join(dir, "b.txt")); err != nil {
		t.Fatal(err)
	}
	write("c.txt", strings.Repeat("x", 180)+"\n")
	write("note file.txt", "spatie\n")
	var huge strings.Builder
	for i := 0; i < 220; i++ {
		huge.WriteString("regel\n")
	}
	write("huge.txt", huge.String())
	write("bin.dat", "a\x00b\n")
	git("add", "-A")
	git("mv", "a.txt", "a2.txt")
	git("commit", "-m", "wijzig bestanden", "-m", "tweede alinea")
	mixed := rev(t, dir)

	parents, files, err = CommitPatch(ctx, "git", dir, mixed)
	if err != nil {
		t.Fatal(err)
	}
	if len(parents) != 1 || parents[0] != root {
		t.Fatalf("parents: %v", parents)
	}
	byPath := map[string]PatchFile{}
	for _, f := range files {
		byPath[f.Path] = f
	}
	if byPath["a2.txt"].Status != "renamed" || byPath["a2.txt"].OldPath != "a.txt" {
		t.Fatalf("rename: %+v", byPath["a2.txt"])
	}
	if byPath["b.txt"].Status != "deleted" || byPath["b.txt"].Deleted != 1 {
		t.Fatalf("delete: %+v", byPath["b.txt"])
	}
	if byPath["c.txt"].Status != "added" || byPath["c.txt"].Added != 1 {
		t.Fatalf("add: %+v", byPath["c.txt"])
	}
	if byPath["note file.txt"].Status != "added" {
		t.Fatalf("spatie: %+v", byPath["note file.txt"])
	}
	if !byPath["bin.dat"].Binary || len(byPath["bin.dat"].Lines) != 0 {
		t.Fatalf("binair: %+v", byPath["bin.dat"])
	}
	if byPath["huge.txt"].Added != 220 {
		t.Fatalf("groot: %+v", byPath["huge.txt"])
	}
	if byPath["keep.go"].Status != "modified" || byPath["keep.go"].Added < 1 {
		t.Fatalf("go: %+v", byPath["keep.go"])
	}

	git("checkout", "-b", "side")
	write("side.txt", "zijtak\n")
	git("add", "side.txt")
	git("commit", "-m", "zijtak")
	git("checkout", "master")
	git("merge", "--no-ff", "side", "-m", "voeg zijtak samen")
	merge := rev(t, dir)
	parents, files, err = CommitPatch(ctx, "git", dir, merge)
	if err != nil {
		t.Fatal(err)
	}
	if len(parents) != 2 || parents[0] != mixed {
		t.Fatalf("merge-parents: %v mixed=%s", parents, mixed)
	}
	if len(files) != 1 || files[0].Path != "side.txt" || files[0].Status != "added" {
		t.Fatalf("merge-diff: %+v", files)
	}
}

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