package server

import (
	"context"
	"net/http"
	"net/http/httptest"
	"net/url"
	"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 TestDeleteBranchWithSlash(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() })
	ctx := context.Background()
	ada, err := st.UpsertUser(ctx, 1, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	token, _, err := st.IssueToken(ctx, ada.ID, store.TokenRequest{Name: "ada", Scopes: "api"})
	if err != nil {
		t.Fatal(err)
	}
	cfg := config.Config{
		BaseURL: "http://127.0.0.1:9", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "ada", DevAuthID: 1},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "ada", AuthID: 1}, Git: "git", HookBin: "/bin/true", StateDir: t.TempDir()}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)

	call := func(method, path, body string) (int, string) {
		t.Helper()
		req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
		if err != nil {
			t.Fatal(err)
		}
		req.Header.Set("Authorization", "Bearer "+token)
		if body != "" {
			req.Header.Set("Content-Type", "application/json")
		}
		res, err := http.DefaultClient.Do(req)
		if err != nil {
			t.Fatal(err)
		}
		return res.StatusCode, read(t, res)
	}
	code, body := call(http.MethodPost, "/api/v1/projects", `{"name":"demo","visibility":"public","initialize_with_readme":true}`)
	if code != 201 {
		t.Fatalf("project %d %s", code, body)
	}
	const name = "cursor/api-schemas-65da"
	dir := gitrepo.Dir(storage, "ada", "demo")
	exists := func() bool {
		t.Helper()
		out, err := exec.Command("git", "-C", dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name).Output()
		return err == nil && strings.TrimSpace(string(out)) != ""
	}
	recreate := func() {
		t.Helper()
		if exists() {
			return
		}
		code, body := call(http.MethodPost, "/api/v1/projects/ada/demo/repository/branches", `{"name":"`+name+`","from":"master"}`)
		if code != 201 {
			t.Fatalf("aanmaken %d %s", code, body)
		}
	}
	deleteAt := func(path, confirm string, status int) {
		t.Helper()
		recreate()
		code, body := call(http.MethodDelete, path, `{"confirm":"`+confirm+`"}`)
		if code != status {
			t.Fatalf("DELETE %s confirm %q: %d %s", path, confirm, code, body)
		}
	}
	base := "/api/v1/projects/ada/demo/repository/branches/"
	deleteAt(base+"cursor/api-schemas-65da", name, http.StatusNoContent)
	if exists() {
		t.Fatal("letterlijke slash hoort de branch te verwijderen")
	}
	deleteAt(base+"cursor%2Fapi-schemas-65da", name, http.StatusNoContent)
	if exists() {
		t.Fatal("procent-2F hoort de branch te verwijderen")
	}
	deleteAt(base+"cursor%2Fapi-schemas-65da", "cursor%2Fapi-schemas-65da", http.StatusNoContent)
	if exists() {
		t.Fatal("gecodeerde bevestiging hoort ook te werken")
	}
	deleteAt(base+"cursor%252Fapi-schemas-65da", name, http.StatusNoContent)
	if exists() {
		t.Fatal("dubbel gecodeerde slash hoort de branch te verwijderen")
	}
	deleteAt(base+"cursor%2Fapi-schemas-65da", "andere-tak", http.StatusBadRequest)
	if !exists() {
		t.Fatal("foute bevestiging mag de branch niet verwijderen")
	}

	// Varianten zonder slash in het pad, voor een ingress die %2F weigert.
	recreate()
	code, body = call(http.MethodDelete, "/api/v1/projects/ada/demo/repository/branches?name="+url.QueryEscape(name), "")
	if code != http.StatusNoContent {
		t.Fatalf("DELETE ?name= %d %s", code, body)
	}
	if exists() {
		t.Fatal("query name hoort de branch te verwijderen")
	}
	recreate()
	code, body = call(http.MethodDelete, "/api/v1/projects/ada/demo/repository/branches", `{"name":"`+name+`"}`)
	if code != http.StatusNoContent {
		t.Fatalf("DELETE body name %d %s", code, body)
	}
	if exists() {
		t.Fatal("body name hoort de branch te verwijderen")
	}
	recreate()
	code, body = call(http.MethodDelete, "/api/v1/projects/ada/demo/repository/branches", `{"name":"`+name+`","confirm":"andere-tak"}`)
	if code != http.StatusBadRequest {
		t.Fatalf("DELETE body verkeerde confirm %d %s", code, body)
	}
	if !exists() {
		t.Fatal("verkeerde confirm mag de branch niet verwijderen")
	}
	code, body = call(http.MethodPut, "/api/v1/projects/ada/demo/repository/branches?name="+url.QueryEscape(name), `{"name":"cursor/hernoemd"}`)
	if code != http.StatusOK {
		t.Fatalf("PUT ?name= %d %s", code, body)
	}
	if exists() {
		t.Fatal("oude naam hoort weg te zijn na hernoemen")
	}
	out, err := exec.Command("git", "-C", dir, "rev-parse", "--verify", "--quiet", "refs/heads/cursor/hernoemd").Output()
	if err != nil || strings.TrimSpace(string(out)) == "" {
		t.Fatal("nieuwe naam ontbreekt")
	}
}

func TestSlashAvoidingRefEndpoints(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() })
	ctx := context.Background()
	ada, err := st.UpsertUser(ctx, 1, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	token, _, err := st.IssueToken(ctx, ada.ID, store.TokenRequest{Name: "ada", Scopes: "api"})
	if err != nil {
		t.Fatal(err)
	}
	cfg := config.Config{
		BaseURL: "http://127.0.0.1:9", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "ada", DevAuthID: 1},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "ada", AuthID: 1}, Git: "git", HookBin: "/bin/true", StateDir: t.TempDir()}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)

	call := func(method, path, body string) (int, string) {
		t.Helper()
		req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
		if err != nil {
			t.Fatal(err)
		}
		req.Header.Set("Authorization", "Bearer "+token)
		if body != "" {
			req.Header.Set("Content-Type", "application/json")
		}
		res, err := http.DefaultClient.Do(req)
		if err != nil {
			t.Fatal(err)
		}
		return res.StatusCode, read(t, res)
	}
	code, body := call(http.MethodPost, "/api/v1/projects", `{"name":"demo","visibility":"public","initialize_with_readme":true}`)
	if code != 201 {
		t.Fatalf("project %d %s", code, body)
	}
	code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/commits", `{"branch":"master","commit_message":"pad","actions":[{"action":"create","file_path":"docs/INGRESS.md","content":"# Ingress\n"}]}`)
	if code != 201 {
		t.Fatalf("commit %d %s", code, body)
	}
	code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/repository/files?path="+url.QueryEscape("docs/INGRESS.md")+"&ref=master", "")
	if code != 200 || !strings.Contains(body, "# Ingress") {
		t.Fatalf("GET files?path= %d %s", code, body)
	}
	code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/repository/files/docs%2FINGRESS.md?ref=master", "")
	if code != 200 || !strings.Contains(body, "# Ingress") {
		t.Fatalf("GET files %%2F %d %s", code, body)
	}

	const pattern = "feature/*"
	code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/protected_branches", `{"pattern":"`+pattern+`"}`)
	if code != 201 {
		t.Fatalf("protect %d %s", code, body)
	}
	code, body = call(http.MethodDelete, "/api/v1/projects/ada/demo/protected_branches?pattern="+url.QueryEscape(pattern), "")
	if code != http.StatusNoContent {
		t.Fatalf("unprotect ?pattern= %d %s", code, body)
	}
	code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/protected_branches", `{"pattern":"`+pattern+`"}`)
	if code != 201 {
		t.Fatalf("protect opnieuw %d %s", code, body)
	}
	code, body = call(http.MethodDelete, "/api/v1/projects/ada/demo/protected_branches", `{"pattern":"`+pattern+`"}`)
	if code != http.StatusNoContent {
		t.Fatalf("unprotect body pattern %d %s", code, body)
	}
	code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/protected_branches", "")
	if code != 200 || strings.Contains(body, "feature/") {
		t.Fatalf("pattern zou weg moeten zijn: %d %s", code, body)
	}

	const tagPat = "releases/*"
	code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/protected_tags", `{"pattern":"`+tagPat+`"}`)
	if code != 201 {
		t.Fatalf("protect tag %d %s", code, body)
	}
	code, body = call(http.MethodDelete, "/api/v1/projects/ada/demo/protected_tags?pattern="+url.QueryEscape(tagPat), "")
	if code != http.StatusNoContent {
		t.Fatalf("unprotect tag ?pattern= %d %s", code, body)
	}
}

func TestPathWildcardEncodedSlash(t *testing.T) {
	mux := http.NewServeMux()
	var got string
	mux.HandleFunc("DELETE /branches/{branch...}", func(w http.ResponseWriter, r *http.Request) {
		got = pathWildcard(r, "branch")
		w.WriteHeader(http.StatusNoContent)
	})
	ts := httptest.NewServer(mux)
	t.Cleanup(ts.Close)
	for _, path := range []string{"/branches/feature/x", "/branches/feature%2Fx", "/branches/feature%252Fx"} {
		got = ""
		req, err := http.NewRequest(http.MethodDelete, ts.URL+path, nil)
		if err != nil {
			t.Fatal(err)
		}
		res, err := http.DefaultClient.Do(req)
		if err != nil {
			t.Fatal(err)
		}
		res.Body.Close()
		if res.StatusCode != http.StatusNoContent {
			t.Fatalf("%s: %d", path, res.StatusCode)
		}
		if got != "feature/x" {
			t.Fatalf("%s: pathWildcard=%q", path, got)
		}
	}
}

func TestRetryPipelineModeDefault(t *testing.T) {
	if retryPipelineMode("") != "failed" || retryPipelineMode("  ") != "failed" {
		t.Fatal("lege mode hoort failed te zijn")
	}
	if retryPipelineMode("all") != "all" || retryPipelineMode("failed") != "failed" {
		t.Fatal("expliciete mode moet blijven")
	}
}

func TestPushDeletesSourceBranch(t *testing.T) {
	srv, ts, st := mergeFixServer(t)
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)
	work := pushPair(t, ts, token, "weg", "een\n", "twee\n")
	page := read(t, mustGet(t, tim, ts.URL+"/tim/weg/-/merge-requests/new?source=topic&target=master"))
	_ = read(t, mustPost(t, tim, ts.URL+"/tim/weg/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Weg"}, "source": {"topic"}, "target": {"master"},
		"remove_source_branch": {"1"},
	}))
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "weg")
	if err != nil {
		t.Fatal(err)
	}
	mr, err := st.MergeRequestByNumber(ctx, repo.ID, 1)
	if err != nil || !mr.RemoveSourceBranch {
		t.Fatalf("remove_source_branch hoort aan te staan: %+v %v", mr, err)
	}
	git(t, work, "checkout", "master")
	git(t, work, "merge", "--no-edit", "topic")
	git(t, work, "push", "origin", "master")
	mr, err = st.MergeRequestByNumber(ctx, repo.ID, 1)
	if err != nil || mr.Status != "merged" {
		t.Fatalf("status %s %v", mr.Status, err)
	}
	if branchRefExists(t, srv, "tim", "weg", "topic") {
		t.Fatal("bronbranch hoort weg te zijn")
	}
	if !branchRefExists(t, srv, "tim", "weg", "master") {
		t.Fatal("master hoort te blijven")
	}
}

func TestPushKeepsSourceBranch(t *testing.T) {
	srv, ts, st := mergeFixServer(t)
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)

	work := pushPair(t, ts, token, "blijft", "een\n", "twee\n")
	page := read(t, mustGet(t, tim, ts.URL+"/tim/blijft/-/merge-requests/new?source=topic&target=master"))
	_ = read(t, mustPost(t, tim, ts.URL+"/tim/blijft/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Blijft"}, "source": {"topic"}, "target": {"master"},
	}))
	git(t, work, "checkout", "master")
	git(t, work, "merge", "--no-edit", "topic")
	git(t, work, "push", "origin", "master")
	if !branchRefExists(t, srv, "tim", "blijft", "topic") {
		t.Fatal("uitgezette remove_source_branch hoort de tak te laten staan")
	}

	work = pushPair(t, ts, token, "slot", "een\n", "twee\n")
	page = read(t, mustGet(t, tim, ts.URL+"/tim/slot/-/merge-requests/new?source=topic&target=master"))
	_ = read(t, mustPost(t, tim, ts.URL+"/tim/slot/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Slot"}, "source": {"topic"}, "target": {"master"},
		"remove_source_branch": {"1"},
	}))
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "slot")
	if err != nil {
		t.Fatal(err)
	}
	if err := st.AddProtected(ctx, repo.ID, "topic"); err != nil {
		t.Fatal(err)
	}
	git(t, work, "checkout", "master")
	git(t, work, "merge", "--no-edit", "topic")
	git(t, work, "push", "origin", "master")
	mr, err := st.MergeRequestByNumber(ctx, repo.ID, 1)
	if err != nil || mr.Status != "merged" {
		t.Fatalf("protected bron hoort de MR wel merged te zetten: %s %v", mr.Status, err)
	}
	if !branchRefExists(t, srv, "tim", "slot", "topic") {
		t.Fatal("beschermde bronbranch hoort te blijven")
	}
}

func branchRefExists(t *testing.T, srv *Server, owner, repo, branch string) bool {
	t.Helper()
	dir := gitrepo.Dir(srv.StoragePath(), owner, repo)
	out, err := exec.Command(srv.Git, "-C", dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch).Output()
	return err == nil && strings.TrimSpace(string(out)) != ""
}
