package server

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"net/url"
	"path/filepath"
	"strings"
	"testing"

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

func TestSourceDeleteSkip(t *testing.T) {
	if got := sourceDeleteSkip(access.RoleDeveloper, "master", "topic", true, false); got != "" {
		t.Fatalf("mag weg: %s", got)
	}
	cases := []struct {
		role      access.Role
		def, name string
		exists    bool
		protected bool
		want      string
	}{
		{access.RoleDeveloper, "master", "topic", false, false, "missing"},
		{access.RoleDeveloper, "master", "", true, false, "missing"},
		{access.RoleDeveloper, "master", "master", true, false, "default"},
		{access.RoleMaintainer, "master", "topic", true, true, "protected"},
		{access.RoleReporter, "master", "topic", true, false, "forbidden"},
	}
	for _, c := range cases {
		if got := sourceDeleteSkip(c.role, c.def, c.name, c.exists, c.protected); got != c.want {
			t.Fatalf("%+v gaf %s", c, got)
		}
	}
}

func TestMergeFormDeletesSource(t *testing.T) {
	srv, ts, st := mergeFixServer(t)
	var bodies [][]byte
	srv.hookSink = func(b []byte) { bodies = append(bodies, append([]byte(nil), b...)) }
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)
	work := pushPair(t, ts, token, "weg", "alpha\n", "beta\n")
	page := read(t, mustGet(t, tim, ts.URL+"/tim/weg/-/merge-requests/new?source=topic&target=master"))
	if !strings.Contains(page, `name="remove_source_branch" value="1" checked`) || !strings.Contains(page, "Delete source branch after merge") {
		t.Fatalf("bronbranch staat niet standaard aan:\n%s", page)
	}
	if !strings.Contains(page, `name="squash" value="1">`) || !strings.Contains(page, "Squash commits") || strings.Contains(page, `name="squash" value="1" checked`) {
		t.Fatalf("squash staat niet standaard uit:\n%s", page)
	}
	if !strings.Contains(page, `name="squash_commit_message">verder</textarea>`) {
		t.Fatalf("squashbericht is niet de titel:\n%s", page)
	}
	page = read(t, mustPost(t, tim, ts.URL+"/tim/weg/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Bewaar"}, "source": {"topic"}, "target": {"master"},
	}))
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "weg")
	if err != nil {
		t.Fatal(err)
	}
	kept, err := st.MergeRequestByNumber(ctx, repo.ID, 1)
	if err != nil || kept.RemoveSourceBranch || kept.Squash {
		t.Fatalf("ontbrekend vakje hoort uit: %+v %v", kept, err)
	}
	_ = read(t, mustPost(t, tim, ts.URL+"/tim/weg/-/merge-requests/1/close", url.Values{"csrf": {csrfOf(t, page)}}))

	page = read(t, mustGet(t, tim, ts.URL+"/tim/weg/-/merge-requests/new?source=topic&target=master"))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/weg/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Weg ermee"}, "source": {"topic"}, "target": {"master"},
		"remove_source_branch": {"1"}, "squash_commit_message": {"later"},
	}))
	if !strings.Contains(page, `name="remove_source_branch" value="1" checked`) || !strings.Contains(page, ">later</textarea>") {
		t.Fatalf("mergeformulier:\n%s", page)
	}
	if _, err := st.CreateWebhook(ctx, store.Webhook{
		ScopeKind: "repo", ScopeID: repo.ID, Name: "push", Preset: "generic",
		URLTemplate: "https://example.test/hook", Events: []string{"push"},
	}); err != nil {
		t.Fatal(err)
	}
	bodies = nil
	merged := read(t, mustPost(t, tim, ts.URL+"/tim/weg/-/merge-requests/2/merge", url.Values{
		"csrf": {csrfOf(t, page)}, "remove_source_branch": {"1"},
	}))
	if !strings.Contains(merged, "Merged and deleted branch topic.") {
		t.Fatalf("feedback:\n%s", merged)
	}
	git(t, work, "fetch", "--prune", "origin")
	if _, err := gitOut(work, "rev-parse", "--verify", "refs/remotes/origin/topic"); err == nil {
		t.Fatal("bronbranch bestaat nog")
	}
	parents := strings.Fields(mustGit(t, work, "rev-list", "--parents", "-n", "1", "origin/master"))
	if len(parents) != 3 {
		t.Fatalf("gewone merge hoort twee ouders te hebben: %v", parents)
	}
	push := decodeKind(t, bodies, "push")
	if push["ref"] != "refs/heads/topic" || push["after"] != strings.Repeat("0", 40) || push["before"] == strings.Repeat("0", 40) {
		t.Fatalf("verwijder-webhook %s", mustJSON(t, push))
	}
}

func TestMergeKeepsProtectedAndDefault(t *testing.T) {
	_, ts, st := mergeFixServer(t)
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)
	work := pushPair(t, ts, token, "slot", "alpha\n", "beta\n")
	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)
	}
	page := read(t, mustGet(t, tim, ts.URL+"/tim/slot/-/merge-requests/new?source=topic&target=master"))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/slot/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Beschermd"}, "source": {"topic"}, "target": {"master"},
		"remove_source_branch": {"1"},
	}))
	kept := read(t, mustPost(t, tim, ts.URL+"/tim/slot/-/merge-requests/1/merge", url.Values{
		"csrf": {csrfOf(t, page)}, "remove_source_branch": {"1"},
	}))
	if !strings.Contains(kept, "Branch topic stays because it is protected.") {
		t.Fatalf("beschermd:\n%s", kept)
	}
	git(t, work, "fetch", "origin")
	if mustGit(t, work, "rev-parse", "--verify", "refs/remotes/origin/topic") == "" {
		t.Fatal("beschermde branch weg")
	}

	defWork := pushPair(t, ts, token, "omlaag", "alpha\n", "beta\n")
	git(t, defWork, "checkout", "master")
	writeFile(t, filepath.Join(defWork, "extra.txt"), "extra\n")
	git(t, defWork, "add", "extra.txt")
	git(t, defWork, "commit", "-m", "op master")
	git(t, defWork, "push", "origin", "master")
	page = read(t, mustGet(t, tim, ts.URL+"/tim/omlaag/-/merge-requests/new?source=master&target=topic"))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/omlaag/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Standaard"}, "source": {"master"}, "target": {"topic"},
		"remove_source_branch": {"1"},
	}))
	stayed := read(t, mustPost(t, tim, ts.URL+"/tim/omlaag/-/merge-requests/1/merge", url.Values{
		"csrf": {csrfOf(t, page)}, "remove_source_branch": {"1"},
	}))
	if !strings.Contains(stayed, "Branch master stays because it is the default branch.") {
		t.Fatalf("standaard:\n%s", stayed)
	}
	git(t, defWork, "fetch", "origin")
	if mustGit(t, defWork, "rev-parse", "--verify", "refs/remotes/origin/master") == "" {
		t.Fatal("standaardbranch weg")
	}
}

func TestMergeOptionsAPI(t *testing.T) {
	_, ts, st := mergeFixServer(t)
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)
	work := pushPair(t, ts, token, "apiopt", "alpha\n", "beta\n")
	writeFile(t, filepath.Join(work, "more.txt"), "meer\n")
	git(t, work, "add", "more.txt")
	git(t, work, "commit", "-m", "tweede")
	git(t, work, "push", "origin", "topic")

	spec := apiCall(t, ts, http.MethodGet, "/api/v1/openapi.json", token, "")
	if !strings.Contains(spec, `"remove_source_branch"`) || !strings.Contains(spec, `"squash"`) || !strings.Contains(spec, "squash_commit_message") {
		t.Fatalf("openapi mist de velden: %s", spec)
	}
	created := decodeBody(t, apiCall(t, ts, http.MethodPost, "/api/v1/projects/tim/apiopt/merge_requests", token,
		`{"title":"Standaard","source_branch":"topic","target_branch":"master"}`))
	if created["remove_source_branch"] != true || created["squash"] != false || created["squash_commit_message"] != "" {
		t.Fatalf("api-standaard %s", mustJSON(t, created))
	}
	updated := decodeBody(t, apiCall(t, ts, http.MethodPut, "/api/v1/projects/tim/apiopt/merge_requests/1", token,
		`{"title":"Standaard","remove_source_branch":false,"squash":true,"squash_commit_message":"bewaard"}`))
	if updated["remove_source_branch"] != false || updated["squash"] != true || updated["squash_commit_message"] != "bewaard" {
		t.Fatalf("put %s", mustJSON(t, updated))
	}
	second := decodeBody(t, apiCall(t, ts, http.MethodPost, "/api/v1/projects/tim/apiopt/merge_requests", token,
		`{"title":"Squash mij","source_branch":"topic","target_branch":"master","remove_source_branch":false,"squash":true,"squash_commit_message":"eerste tekst"}`))
	if second["iid"] != float64(2) || second["squash"] != true || second["remove_source_branch"] != false {
		t.Fatalf("tweede %s", mustJSON(t, second))
	}
	merged := decodeBody(t, apiCall(t, ts, http.MethodPost, "/api/v1/projects/tim/apiopt/merge_requests/2/merge", token,
		`{"remove_source_branch":true,"squash":true,"squash_commit_message":"een bericht\n\ntweede regel"}`))
	if merged["state"] != "merged" || merged["source_branch_removed"] != true || merged["source_branch_skip"] != "" {
		t.Fatalf("merge %s", mustJSON(t, merged))
	}
	git(t, work, "fetch", "--prune", "origin")
	if _, err := gitOut(work, "rev-parse", "--verify", "refs/remotes/origin/topic"); err == nil {
		t.Fatal("api liet de bronbranch staan")
	}
	msg := strings.TrimSpace(mustGit(t, work, "log", "-1", "--format=%B", "origin/master"))
	if msg != "een bericht\n\ntweede regel" {
		t.Fatalf("squashbericht %q", msg)
	}
	parents := strings.Fields(mustGit(t, work, "rev-list", "--parents", "-n", "1", "origin/master"))
	if len(parents) != 2 {
		t.Fatalf("squash hoort geen merge-commit te zijn: %v", parents)
	}
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "apiopt")
	if err != nil {
		t.Fatal(err)
	}
	stored, err := st.MergeRequestByNumber(ctx, repo.ID, 2)
	if err != nil || !stored.Squash || !stored.RemoveSourceBranch || stored.SquashMessage != "een bericht\n\ntweede regel" {
		t.Fatalf("bewaard na merge %+v %v", stored, err)
	}
}

func apiCall(t *testing.T, ts *httptest.Server, method, path, token, body string) string {
	t.Helper()
	var rdr *strings.Reader
	if body != "" {
		rdr = strings.NewReader(body)
	}
	var req *http.Request
	var err error
	if rdr == nil {
		req, err = http.NewRequest(method, ts.URL+path, nil)
	} else {
		req, err = http.NewRequest(method, ts.URL+path, rdr)
	}
	if err != nil {
		t.Fatal(err)
	}
	if body != "" {
		req.Header.Set("Content-Type", "application/json")
	}
	if token != "" {
		req.Header.Set("Authorization", "Bearer "+token)
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	raw := read(t, res)
	if res.StatusCode < 200 || res.StatusCode >= 300 {
		t.Fatalf("%s %s: %d %s", method, path, res.StatusCode, raw)
	}
	return raw
}

func decodeBody(t *testing.T, raw string) map[string]any {
	t.Helper()
	var doc map[string]any
	if err := json.Unmarshal([]byte(raw), &doc); err != nil {
		t.Fatalf("json %v %s", err, raw)
	}
	return doc
}
