package server

import (
	"context"
	"net/http"
	"net/http/cookiejar"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"gitlab.com/Timfa/bluegit/internal/auth"
	"gitlab.com/Timfa/bluegit/internal/config"
	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/store"
)

func TestPresentCommitTree(t *testing.T) {
	files := []gitrepo.PatchFile{
		{Status: "added", Path: "src/util.go", Added: 2, Lines: []gitrepo.DiffLine{{Kind: "add", New: 1, Text: "func util() {}"}}},
		{Status: "renamed", Path: "a2.txt", OldPath: "a.txt"},
		{Status: "added", Path: "huge.txt", Added: largeChange + 1, Lines: []gitrepo.DiffLine{{Kind: "add", New: 1, Text: "x"}}},
	}
	d := presentCommitDiff("tim/demo", "abcdef1234567890", []string{"1234abcd1234abcd1234abcd1234abcd1234abcd"}, files)
	if d.FilesN != 3 || len(d.Parents) != 1 || d.Parents[0].Short != "1234abcd" {
		t.Fatalf("kop: %+v", d)
	}
	if !d.Files[2].Collapsed || d.Files[0].Collapsed {
		t.Fatalf("inklappen: util %v huge %v", d.Files[0].Collapsed, d.Files[2].Collapsed)
	}
	if !strings.Contains(string(d.Files[0].Lines[0].HTML), "hl-k") {
		t.Fatalf("geen highlight: %s", d.Files[0].Lines[0].HTML)
	}
	if d.Files[0].Pairs[0].RKind != "add" || d.Files[0].Pairs[0].RNo != 1 || d.Files[0].Pairs[0].LKind != "" {
		t.Fatalf("paar: %+v", d.Files[0].Pairs)
	}
	var dirs, nested bool
	for _, row := range d.Tree {
		if row.Dir && row.Name == "src" && row.Depth == 0 {
			dirs = true
		}
		if row.Name == "util.go" && row.Depth == 1 && row.Anchor != "" {
			nested = true
		}
	}
	if !dirs || !nested {
		t.Fatalf("boom: %+v", d.Tree)
	}
	if !strings.Contains(d.Files[0].FileURL, "/tim/demo/-/blob/src/util.go?rev=abcdef1234567890") {
		t.Fatal(d.Files[0].FileURL)
	}
}

func TestCommitDetailPage(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	storage := t.TempDir()
	st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	cfg := config.Config{
		BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	page := read(t, res)
	res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"diffdemo"}, "visibility": {"public"},
	})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"laptop"}})
	if err != nil {
		t.Fatal(err)
	}
	token := between(read(t, res), `<p class="code">`, "</p>")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/diffdemo.git"
	work := t.TempDir()
	git(t, work, "init", "-b", "master")
	git(t, work, "config", "user.email", "tim@users.git.timfalken.com")
	git(t, work, "config", "user.name", "tim")
	git(t, work, "config", "commit.gpgsign", "false")
	writeFile(t, filepath.Join(work, "a.txt"), "alpha\n")
	writeFile(t, filepath.Join(work, "b.txt"), "beta\n")
	writeFile(t, filepath.Join(work, "keep.go"), "package p\n\nfunc keep() {}\n")
	git(t, work, "add", ".")
	git(t, work, "commit", "-m", "begin")
	root := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))
	writeFile(t, filepath.Join(work, "keep.go"), "package p\n\nfunc keep() {}\nfunc extra() {}\n")
	if err := os.Remove(filepath.Join(work, "b.txt")); err != nil {
		t.Fatal(err)
	}
	writeFile(t, filepath.Join(work, "c.txt"), strings.Repeat("x", 180)+"\n")
	writeFile(t, filepath.Join(work, "note file.txt"), "spatie\n")
	writeFile(t, filepath.Join(work, "src", "util.go"), "package src\n\nfunc util() {}\n")
	var huge strings.Builder
	for i := 0; i < 220; i++ {
		huge.WriteString("regel\n")
	}
	writeFile(t, filepath.Join(work, "huge.txt"), huge.String())
	writeFile(t, filepath.Join(work, "bin.dat"), "a\x00b\n")
	git(t, work, "add", "-A")
	git(t, work, "mv", "a.txt", "a2.txt")
	git(t, work, "commit", "-m", "wijzig bestanden", "-m", "tweede alinea")
	mixed := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")
	git(t, work, "checkout", "-b", "side")
	writeFile(t, filepath.Join(work, "side.txt"), "zijtak\n")
	git(t, work, "add", "side.txt")
	git(t, work, "commit", "-m", "zijtak")
	git(t, work, "checkout", "master")
	git(t, work, "merge", "--no-ff", "side", "-m", "voeg zijtak samen")
	merge := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))
	git(t, work, "push", "origin", "master")

	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "diffdemo")
	if err != nil {
		t.Fatal(err)
	}
	pipeID, err := st.CreatePipeline(ctx, repo.ID, mixed, "refs/heads/master", "push", "tim", "wijzig bestanden", []store.NewJob{
		{Name: "lint", Stage: "test", Script: "exit 0"},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, _ := st.JobsByPipeline(ctx, pipeID)
	for _, j := range jobs {
		if err := st.FinishJob(ctx, j.ID, "success", ""); err != nil {
			t.Fatal(err)
		}
	}
	if status, err := st.RefreshPipelineStatus(ctx, pipeID); err != nil || status != "success" {
		t.Fatalf("pipeline: %s %v", status, err)
	}

	res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + mixed)
	if err != nil {
		t.Fatal(err)
	}
	body := read(t, res)
	for _, want := range []string{
		"wijzig bestanden", "tweede alinea", "Authored",
		`data-copy="` + mixed + `"`,
		"/tim/diffdemo/-/commit/" + root,
		"Parent",
		`class="status passed"`, "Passed",
		"a.txt", "a2.txt", "renamed",
		"b.txt", "deleted",
		"note file.txt", "added",
		"Binary file", "The contents of this binary file are not shown.",
		`data-path="huge.txt"`, `data-collapsed="1"`, "Show diff",
		`data-path="keep.go"`, `data-collapsed="0"`, "Hide diff",
		"hl-k", "func", "src", "util.go",
		`data-diff-mode="side"`, "Side-by-side",
		"/assets/commit-mode.js", `class="d1"`,
		strings.Repeat("x", 180),
		"Changed files",
	} {
		if !strings.Contains(body, want) {
			t.Errorf("pagina mist %q", want)
		}
	}
	if strings.Contains(body, "commit.show") {
		t.Fatal("vertaling ontbreekt")
	}
	keep := section(body, `data-path="keep.go"`)
	if !strings.Contains(keep, `class="ln">1</span>`) || !strings.Contains(keep, "kind-add") || !strings.Contains(keep, "extra") || !strings.Contains(keep, "hl-k") {
		i := strings.Index(body, `data-path="keep.go"`)
		j := strings.Index(body[i:], "</section>")
		k := strings.Index(body[i:], "kind-add")
		t.Fatalf("keep.go mist delen ln=%v add=%v extra=%v hl=%v section-op=%d add-op=%d keep-len=%d",
			strings.Contains(keep, `class="ln">1</span>`), strings.Contains(keep, "kind-add"),
			strings.Contains(keep, "extra"), strings.Contains(keep, "hl-k"), j, k, len(keep))
	}
	gone := section(body, `data-path="b.txt"`)
	if !strings.Contains(gone, "kind-del") || !strings.Contains(gone, `class="ln">1</span>`) {
		t.Fatal("b.txt mist het verwijderde regelnummer")
	}

	res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + merge)
	if err != nil {
		t.Fatal(err)
	}
	mergePage := read(t, res)
	if !strings.Contains(mergePage, "Parents") || !strings.Contains(mergePage, "/tim/diffdemo/-/commit/"+mixed) || !strings.Contains(mergePage, `data-path="side.txt"`) {
		t.Fatal("mergepagina mist parents of side.txt")
	}
	if strings.Contains(mergePage, `data-path="huge.txt"`) || strings.Contains(mergePage, `data-path="keep.go"`) {
		t.Fatal("merge-diff toont meer dan de eerste parent")
	}

	res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + root)
	if err != nil {
		t.Fatal(err)
	}
	rootPage := read(t, res)
	if strings.Contains(rootPage, "Parent") || !strings.Contains(rootPage, `data-path="a.txt"`) || !strings.Contains(rootPage, "added") {
		t.Fatal("rootcommit klopt niet")
	}

	res, err = client.Get(ts.URL + "/settings")
	if err != nil {
		t.Fatal(err)
	}
	settings := read(t, res)
	res, err = client.PostForm(ts.URL+"/settings/language", url.Values{"csrf": {csrfOf(t, settings)}, "language": {"nl"}})
	if err != nil {
		t.Fatal(err)
	}
	_ = read(t, res)
	res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + mixed)
	if err != nil {
		t.Fatal(err)
	}
	nl := read(t, res)
	for _, want := range []string{"Toon diff", "hernoemd", "Bovenliggende commit", "Naast elkaar", "Gewijzigde bestanden", "Binair bestand"} {
		if !strings.Contains(nl, want) {
			t.Errorf("Nederlands mist %q", want)
		}
	}
	if strings.Contains(nl, "Show diff") {
		t.Fatal("Engelse diffknop bleef staan")
	}

	res, err = client.Get(ts.URL + "/settings")
	if err != nil {
		t.Fatal(err)
	}
	settings = read(t, res)
	res, err = client.PostForm(ts.URL+"/settings/language", url.Values{"csrf": {csrfOf(t, settings)}, "language": {"cuneiform"}})
	if err != nil {
		t.Fatal(err)
	}
	_ = read(t, res)
	res, err = client.Get(ts.URL + "/tim/diffdemo/-/commit/" + mixed)
	if err != nil {
		t.Fatal(err)
	}
	signs := read(t, res)
	if strings.Contains(signs, "Show diff") || strings.Contains(signs, "Toon diff") || !strings.Contains(signs, mixed) || !strings.Contains(signs, "𒀀") {
		t.Fatal("spijkerschrift of hash klopt niet")
	}
}

func gitOutOK(t *testing.T, dir string, args ...string) string {
	t.Helper()
	out, err := gitOut(dir, args...)
	if err != nil {
		t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
	}
	return out
}

func section(body, marker string) string {
	i := strings.Index(body, marker)
	if i < 0 {
		return ""
	}
	rest := body[i:]
	j := strings.Index(rest, "</section>")
	if j < 0 {
		return rest
	}
	return rest[:j]
}
