package server

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

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

func TestClosingPatterns(t *testing.T) {
	got := closingNumbers("Closes #1", "please Fixes #2.", "```\nCloses #4\n```", "`Resolves #8`", "See #3", "Implements #2")
	if len(got) != 2 || got[0] != 1 || got[1] != 2 {
		t.Fatalf("nummers %v", got)
	}
}

func TestIssues(t *testing.T) {
	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://git.example", 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"},
	}
	var bodies [][]byte
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
	srv.hookSink = func(b []byte) { bodies = append(bodies, append([]byte(nil), b...)) }
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)

	jar, _ := cookiejar.New(nil)
	tim := &http.Client{Jar: jar}
	page := read(t, mustGet(t, tim, ts.URL+"/login"))
	page = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"bugs"}, "visibility": {"public"},
	}))
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "bugs")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.CreateWebhook(ctx, store.Webhook{
		ScopeKind: "repo", ScopeID: repo.ID, Name: "issues", Preset: "generic",
		URLTemplate: "https://example.test/hook", Events: []string{"issue"},
	}); err != nil {
		t.Fatal(err)
	}
	page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"tim"}}))
	timToken := between(page, `<p class="code">`, "</p>")

	ro, err := st.UpsertUser(ctx, 3, "ro", "", false)
	if err != nil {
		t.Fatal(err)
	}
	rep, err := st.UpsertUser(ctx, 4, "rep", "", false)
	if err != nil {
		t.Fatal(err)
	}
	sam, err := st.UpsertUser(ctx, 5, "sam", "", false)
	if err != nil {
		t.Fatal(err)
	}
	dev, err := st.UpsertUser(ctx, 6, "dev", "", false)
	if err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "ro", access.RoleReadonly); err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "rep", access.RoleReporter); err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "dev", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}
	roToken, _ := st.CreateToken(ctx, ro.ID, "ro")
	repToken, _ := st.CreateToken(ctx, rep.ID, "rep")
	samToken, _ := st.CreateToken(ctx, sam.ID, "sam")
	devToken, _ := st.CreateToken(ctx, dev.ID, "dev")

	res := postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/labels", timToken, map[string]any{"name": "bug", "color": "#428fdc"})
	if res.StatusCode != http.StatusCreated {
		t.Fatalf("label %d %s", res.StatusCode, read(t, res))
	}
	res.Body.Close()
	res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/milestones", timToken, map[string]any{"title": "v1", "due_on": "2026-11-01"})
	if res.StatusCode != http.StatusCreated {
		t.Fatalf("mijlpaal %d %s", res.StatusCode, read(t, res))
	}
	res.Body.Close()
	res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/labels", roToken, map[string]any{"name": "nope"})
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("readonly label %d", res.StatusCode)
	}
	res.Body.Close()

	res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", roToken, map[string]any{"title": "Geheim", "labels": []string{"bug"}})
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("readonly labelen %d %s", res.StatusCode, read(t, res))
	}
	res.Body.Close()
	noTok := postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", "", map[string]any{"title": "x"})
	if noTok.StatusCode != http.StatusUnauthorized {
		t.Fatalf("zonder token %d", noTok.StatusCode)
	}
	noTok.Body.Close()
	jobTok := postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", "bgj_fake", map[string]any{"title": "x"})
	if jobTok.StatusCode != http.StatusUnauthorized {
		t.Fatalf("jobtoken %d", jobTok.StatusCode)
	}
	jobTok.Body.Close()

	res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", roToken, map[string]any{
		"title": "Geheim", "description": "niet delen", "confidential": true,
	})
	body := read(t, res)
	if res.StatusCode != http.StatusCreated || !strings.Contains(body, `"id":1`) {
		t.Fatalf("aanmaken %d %s", res.StatusCode, body)
	}
	opened := issuePayload(t, bodies, "opened")
	if opened["comment"] != nil {
		t.Fatalf("opened heeft comment %s", mustJSON(t, opened))
	}
	iss := opened["issue"].(map[string]any)
	if iss["title"] != "Geheim" || iss["confidential"] != true || iss["author"] != "ro" {
		t.Fatalf("payload %s", mustJSON(t, iss))
	}

	res = getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues", samToken)
	list := read(t, res)
	if res.StatusCode != http.StatusOK || strings.Contains(list, "Geheim") {
		t.Fatalf("vreemde lijst %d %s", res.StatusCode, list)
	}
	res = getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/1", samToken)
	if res.StatusCode != http.StatusNotFound {
		t.Fatalf("vreemde detail %d", res.StatusCode)
	}
	res.Body.Close()
	anon := mustGet(t, http.DefaultClient, ts.URL+"/tim/bugs/-/issues/1")
	if anon.StatusCode != http.StatusNotFound {
		t.Fatalf("anoniem %d", anon.StatusCode)
	}
	anon.Body.Close()
	res = getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/1", repToken)
	if res.StatusCode != http.StatusOK || !strings.Contains(read(t, res), "Geheim") {
		t.Fatal("reporter ziet het vertrouwelijke issue niet")
	}

	res = postJSON(t, http.MethodPut, ts.URL+"/api/v1/repos/tim/bugs/issues/1", repToken, map[string]any{
		"labels": []string{"bug"}, "assignees": []string{"ro"}, "milestone": "v1", "due_date": "2026-12-01",
	})
	tagged := read(t, res)
	if res.StatusCode != http.StatusOK || !strings.Contains(tagged, "bug") || !strings.Contains(tagged, "ro") || !strings.Contains(tagged, "v1") {
		t.Fatalf("triage %d %s", res.StatusCode, tagged)
	}
	res = postJSON(t, http.MethodPut, ts.URL+"/api/v1/repos/tim/bugs/issues/1", devToken, map[string]any{"labels": []string{"bug"}})
	if res.StatusCode != http.StatusOK {
		t.Fatalf("developer %d %s", res.StatusCode, read(t, res))
	}
	res = postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues/1/notes", roToken, map[string]any{"body": "zie !4"})
	if res.StatusCode != http.StatusCreated {
		t.Fatalf("reactie %d %s", res.StatusCode, read(t, res))
	}
	commented := issuePayload(t, bodies, "commented")
	if commented["comment"] != "zie !4" {
		t.Fatalf("comment %s", mustJSON(t, commented))
	}

	filtered := read(t, getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues?state=open&label=bug&assignee=ro&q=geheim", repToken))
	if !strings.Contains(filtered, `"id":1`) {
		t.Fatalf("filter %s", filtered)
	}

	roJar, _ := cookiejar.New(nil)
	roClient := &http.Client{Jar: roJar}
	u, _ := url.Parse(ts.URL)
	sess, err := st.CreateSession(ctx, ro.ID, "dev", time.Now().Add(time.Hour))
	if err != nil {
		t.Fatal(err)
	}
	roJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
	page = read(t, mustGet(t, roClient, ts.URL+"/tim/bugs/-/issues"))
	if !strings.Contains(page, "Issues") || !strings.Contains(page, "#1") || !strings.Contains(page, "Geheim") || !strings.Contains(page, "bug") {
		t.Fatalf("lijst\n%s", page)
	}
	page = read(t, mustGet(t, roClient, ts.URL+"/tim/bugs/-/issues/new?relate=1"))
	if !strings.Contains(page, `name="relate"`) || !strings.Contains(page, "value=\"1\"") {
		t.Fatalf("gerelateerd\n%s", page)
	}
	page = read(t, mustPost(t, roClient, ts.URL+"/tim/bugs/-/issues", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Tweede"}, "description": {"Zie #1 en !4"}, "relate": {"1"},
	}))
	if !strings.Contains(page, "#2") || !strings.Contains(page, `/tim/bugs/-/issues/1`) || !strings.Contains(page, `/tim/bugs/-/merge-requests/4`) {
		t.Fatalf("tweede pagina\n%s", page)
	}
	if !strings.Contains(page, "#1 Tweede") && !strings.Contains(page, "#1") {
		t.Fatal("koppeling ontbreekt")
	}

	mr, err := st.CreateMergeRequest(ctx, repo.ID, ro.ID, "Voorbeeld", "tekst", "topic", "master")
	if err != nil {
		t.Fatal(err)
	}
	note, err := st.AddNote(ctx, repo.ID, mr.ID, ro.ID, "dit hoort een issue")
	if err != nil {
		t.Fatal(err)
	}
	form := read(t, mustGet(t, roClient, ts.URL+"/tim/bugs/-/issues/new?from=mr&mr=1&note="+strconv.FormatInt(note.ID, 10)))
	if !strings.Contains(form, "dit hoort een issue") || !strings.Contains(form, "!1") {
		t.Fatalf("prefill\n%s", form)
	}
	prev := read(t, mustPost(t, roClient, ts.URL+"/tim/bugs/-/markdown", url.Values{
		"csrf": {csrfOf(t, form)}, "body": {"zie #1 en !4"},
	}))
	if !strings.Contains(prev, `/tim/bugs/-/issues/1`) || !strings.Contains(prev, `/tim/bugs/-/merge-requests/4`) {
		t.Fatalf("preview %s", prev)
	}

	res = postJSON(t, http.MethodPut, ts.URL+"/api/v1/repos/tim/bugs/issues/1", roToken, map[string]any{"state": "closed"})
	if res.StatusCode != http.StatusOK || !strings.Contains(read(t, res), `"status":"closed"`) {
		t.Fatal("sluiten faalde")
	}
	closed := issuePayload(t, bodies, "closed")
	if closed["issue"].(map[string]any)["status"] != "closed" {
		t.Fatalf("webhook sluiten %s", mustJSON(t, closed))
	}
	closedPage := read(t, mustGet(t, roClient, ts.URL+"/tim/bugs/-/issues?state=closed"))
	if !strings.Contains(closedPage, "Geheim") || strings.Contains(closedPage, "Tweede") {
		t.Fatalf("filter gesloten\n%s", closedPage)
	}

	info := read(t, mustGet(t, http.DefaultClient, ts.URL+"/-/info"))
	for _, want := range []string{`id="issues"`, "Readonly may create issues", "Inloggen faalt", "/api/v1/repos/{owner}/{repo}/issues"} {
		if !strings.Contains(info, want) {
			t.Errorf("info mist %s", want)
		}
	}
}

func TestIssueClosesOnMerge(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://git.example", 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"},
	}
	var bodies [][]byte
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
	srv.hookSink = func(b []byte) { bodies = append(bodies, append([]byte(nil), b...)) }
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	jar, _ := cookiejar.New(nil)
	tim := &http.Client{Jar: jar}
	page := read(t, mustGet(t, tim, ts.URL+"/login"))
	page = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"bugs"}, "visibility": {"private"},
	}))
	page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"tim"}}))
	token := between(page, `<p class="code">`, "</p>")
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "bugs")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.CreateWebhook(ctx, store.Webhook{
		ScopeKind: "repo", ScopeID: repo.ID, Name: "issues", Preset: "generic",
		URLTemplate: "https://example.test/hook", Events: []string{"issue"},
	}); err != nil {
		t.Fatal(err)
	}
	for _, title := range []string{"een", "twee", "drie"} {
		res := postJSON(t, http.MethodPost, ts.URL+"/api/v1/repos/tim/bugs/issues", token, map[string]any{"title": title})
		if res.StatusCode != http.StatusCreated {
			t.Fatalf("issue %s %d %s", title, res.StatusCode, read(t, res))
		}
		res.Body.Close()
	}
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/bugs.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")
	writeFile(t, filepath.Join(work, "README.md"), "a\n")
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "start")
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")
	git(t, work, "checkout", "-b", "topic")
	writeFile(t, filepath.Join(work, "extra.txt"), "c\n")
	git(t, work, "add", "extra.txt")
	git(t, work, "commit", "-m", "Fixes #1")
	git(t, work, "push", "-u", "origin", "topic")

	page = read(t, mustGet(t, tim, ts.URL+"/tim/bugs/-/merge-requests/new?source=topic&target=master"))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/bugs/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "source": {"topic"}, "target": {"master"},
		"title": {"Sluit issues"}, "description": {"Closes #2"},
	}))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/bugs/-/merge-requests/1/notes", url.Values{
		"csrf": {csrfOf(t, page)}, "body": {"dit wordt een issue"},
	}))
	if !strings.Contains(page, "/-/issues/new?from=mr") || !strings.Contains(page, "dit wordt een issue") {
		t.Fatalf("mr-link ontbreekt\n%s", page[:min(800, len(page))])
	}
	page = read(t, mustPost(t, tim, ts.URL+"/tim/bugs/-/merge-requests/1/merge", url.Values{"csrf": {csrfOf(t, page)}}))
	if !strings.Contains(page, "merged") && !strings.Contains(page, "samengevoegd") {
		t.Fatalf("merge\n%s", page[:min(500, len(page))])
	}
	one := read(t, getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/1", token))
	two := read(t, getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/2", token))
	if !strings.Contains(one, `"status":"closed"`) || !strings.Contains(two, `"status":"closed"`) {
		t.Fatalf("na merge\n1 %s\n2 %s", one, two)
	}
	foundClosed := 0
	for _, raw := range bodies {
		var doc map[string]any
		if json.Unmarshal(raw, &doc) != nil || doc["object_kind"] != "issue" {
			continue
		}
		iss, _ := doc["issue"].(map[string]any)
		if iss != nil && iss["action"] == "closed" {
			foundClosed++
		}
	}
	if foundClosed < 2 {
		t.Fatalf("webhooks gesloten %d", foundClosed)
	}

	git(t, work, "checkout", "master")
	git(t, work, "pull", "--ff-only", "origin", "master")
	writeFile(t, filepath.Join(work, "README.md"), "b\n")
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "Resolves #3")
	git(t, work, "push", "origin", "master")
	three := read(t, getBearer(t, ts.URL+"/api/v1/repos/tim/bugs/issues/3", token))
	if !strings.Contains(three, `"status":"closed"`) {
		t.Fatalf("push sluit niet %s", three)
	}
}

func postJSON(t *testing.T, method, raw, token string, body any) *http.Response {
	t.Helper()
	var buf bytes.Buffer
	if body != nil {
		if err := json.NewEncoder(&buf).Encode(body); err != nil {
			t.Fatal(err)
		}
	}
	req, err := http.NewRequest(method, raw, &buf)
	if err != nil {
		t.Fatal(err)
	}
	if token != "" {
		req.Header.Set("Authorization", "Bearer "+token)
	}
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	return res
}

func issuePayload(t *testing.T, bodies [][]byte, action string) map[string]any {
	t.Helper()
	for i := len(bodies) - 1; i >= 0; i-- {
		var doc map[string]any
		if err := json.Unmarshal(bodies[i], &doc); err != nil {
			continue
		}
		iss, _ := doc["issue"].(map[string]any)
		if iss != nil && iss["action"] == action {
			return doc
		}
	}
	t.Fatalf("geen issue-actie %s", action)
	return nil
}
