package server

import (
	"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/auth"
	"gitlab.com/Timfa/bluegit/internal/config"
	"gitlab.com/Timfa/bluegit/internal/store"
	"gitlab.com/Timfa/bluegit/internal/webhook"
)

func TestWebhookPayloads(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": {"hooks"}, "visibility": {"public"},
	}))
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "hooks")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.CreateWebhook(ctx, store.Webhook{
		ScopeKind: "repo", ScopeID: repo.ID, Name: "alles", Preset: "generic",
		URLTemplate: "https://example.test/hook",
		Events:      []string{"push", "merge_request", "pipeline_failure", "release_published"},
	}); err != nil {
		t.Fatal(err)
	}
	if err := st.PutSecret(ctx, "repo", repo.ID, "DEPLOY_TOKEN", "super-secret-token", true); err != nil {
		t.Fatal(err)
	}

	page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"laptop"},
	}))
	token := between(page, `<p class="code">`, "</p>")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/hooks.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", "eerste regel", "-m", "meer tekst")
	writeFile(t, filepath.Join(work, "README.md"), "b\n")
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "tweede")
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")

	push := decodeKind(t, bodies, "push")
	if push["ref"] != "refs/heads/master" || push["before"] != strings.Repeat("0", 40) {
		t.Fatalf("push ref/before %v", push)
	}
	commits := push["commits"].([]any)
	if len(commits) != 2 {
		t.Fatalf("commits %d %s", len(commits), mustJSON(t, push))
	}
	first := commits[0].(map[string]any)
	second := commits[1].(map[string]any)
	if first["message"] != "eerste regel\n\nmeer tekst" || second["message"] != "tweede" {
		t.Fatalf("berichten %v %v", first["message"], second["message"])
	}
	if first["author"] != "tim <tim@users.git.timfalken.com>" || !strings.Contains(first["url"].(string), "/tim/hooks/-/commit/") {
		t.Fatalf("auteur of url %v", first)
	}
	if push["after"] != second["sha"] {
		t.Fatalf("after %v tip %v", push["after"], second["sha"])
	}

	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", "derde")
	git(t, work, "push", "-u", "origin", "topic")

	page = read(t, mustGet(t, tim, ts.URL+"/tim/hooks/-/merge-requests/new?source=topic&target=master"))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/hooks/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "source": {"topic"}, "target": {"master"},
		"title": {"Toon de kloon-URL"}, "description": {"SSH en HTTPS."},
	}))
	opened := decodeAction(t, bodies, "opened")
	mr := opened["merge_request"].(map[string]any)
	if mr["title"] != "Toon de kloon-URL" || mr["description"] != "SSH en HTTPS." || mr["source_branch"] != "topic" || mr["target_branch"] != "master" || mr["status"] != "open" || mr["author"] != "tim" || mr["id"] != float64(1) {
		t.Fatalf("opened %s", mustJSON(t, mr))
	}
	if _, ok := opened["comment"]; ok {
		t.Fatalf("opened heeft een comment: %s", mustJSON(t, opened))
	}

	page = read(t, mustPost(t, tim, ts.URL+"/tim/hooks/-/merge-requests/1/notes", url.Values{
		"csrf": {csrfOf(t, page)}, "body": {"dit is het commentaar"},
	}))
	commented := decodeAction(t, bodies, "commented")
	if commented["comment"] != "dit is het commentaar" {
		t.Fatalf("comment %s", mustJSON(t, commented))
	}

	page = read(t, mustPost(t, tim, ts.URL+"/tim/hooks/-/merge-requests/1/merge", url.Values{
		"csrf": {csrfOf(t, page)},
	}))
	if strings.Contains(page, "flash") && strings.Contains(strings.ToLower(page), "error") {
		t.Fatalf("merge pagina:\n%s", page)
	}
	merged := decodeAction(t, bodies, "merged")
	if merged["merge_request"].(map[string]any)["status"] != "merged" {
		t.Fatalf("merged %s", mustJSON(t, merged))
	}

	sha := second["sha"].(string)
	id, err := st.CreatePipeline(ctx, repo.ID, sha, "refs/heads/master", "push", "tim", "tweede", []store.NewJob{
		{Name: "test", Stage: "test", Script: "exit 1"},
		{Name: "build", Stage: "build", Script: "echo ok"},
		{Name: "soft", Stage: "test", Script: "exit 1", AllowFailure: true},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, err := st.JobsByPipeline(ctx, id)
	if err != nil {
		t.Fatal(err)
	}
	var lines []string
	for i := 0; i < webhook.LogMaxLines+40; i++ {
		lines = append(lines, "regel")
	}
	lines = append(lines, "token super-secret-token")
	log := strings.Join(lines, "\n")
	for _, j := range jobs {
		if _, err := st.MarkJobRunning(ctx, j.ID); err != nil {
			t.Fatal(err)
		}
		switch j.Name {
		case "test":
			if err := st.AppendJobLog(ctx, j.ID, log); err != nil {
				t.Fatal(err)
			}
			if err := st.FinishJob(ctx, j.ID, "failed", ""); err != nil {
				t.Fatal(err)
			}
		case "soft":
			if err := st.AppendJobLog(ctx, j.ID, "zacht super-secret-token\n"); err != nil {
				t.Fatal(err)
			}
			if err := st.FinishJob(ctx, j.ID, "failed", ""); err != nil {
				t.Fatal(err)
			}
		default:
			if err := st.FinishJob(ctx, j.ID, "success", ""); err != nil {
				t.Fatal(err)
			}
		}
	}
	if _, err := st.RefreshPipelineStatus(ctx, id); err != nil {
		t.Fatal(err)
	}
	before := len(bodies)
	srv.Dispatch(repo.ID, webhook.Event{
		Type: webhook.EventPipelineFailure, PipelineID: strconv.FormatInt(id, 10),
	})
	if len(bodies) == before {
		t.Fatal("geen pipeline-payload")
	}
	var pipe map[string]any
	if err := json.Unmarshal(bodies[len(bodies)-1], &pipe); err != nil {
		t.Fatal(err)
	}
	if pipe["object_kind"] != "pipeline" || pipe["type"] != "pipeline_failure" {
		t.Fatalf("pipeline %s", bodies[len(bodies)-1])
	}
	detail := pipe["pipeline"].(map[string]any)
	if detail["id"] != float64(id) || detail["status"] != "failed" || detail["ref"] != "refs/heads/master" || detail["sha"] != sha || detail["author"] != "tim" {
		t.Fatalf("detail %s", mustJSON(t, detail))
	}
	if !strings.Contains(detail["commit_message"].(string), "tweede") {
		t.Fatalf("commit_message %v", detail["commit_message"])
	}
	if _, ok := detail["duration"]; !ok {
		t.Fatal("duur ontbreekt")
	}
	for _, item := range pipe["jobs"].([]any) {
		job := item.(map[string]any)
		raw, _ := json.Marshal(job)
		if strings.Contains(string(raw), "super-secret-token") {
			t.Fatalf("geheim in job %s", raw)
		}
		switch job["name"] {
		case "test":
			if job["log_truncated"] != true || job["allow_failure"] != false {
				t.Fatalf("test %s", raw)
			}
			text := job["log"].(string)
			if !strings.Contains(text, "[MASKED]") || len(strings.Split(text, "\n")) != webhook.LogMaxLines {
				t.Fatalf("log %d regels, staart %q", len(strings.Split(text, "\n")), text[max(0, len(text)-40):])
			}
			if !strings.Contains(job["log_url"].(string), "/log?raw=1") || !strings.Contains(job["web_url"].(string), "/jobs/") {
				t.Fatalf("urls %s", raw)
			}
		case "build":
			if _, ok := job["log"]; ok || job["status"] != "success" {
				t.Fatalf("build %s", raw)
			}
		case "soft":
			if job["allow_failure"] != true || !strings.Contains(job["log"].(string), "[MASKED]") {
				t.Fatalf("soft %s", raw)
			}
		}
	}

	rel := srv.releaseEvent(repo, "v1.2.0", "BlueGit 1.2.0", sha, []store.ReleaseAsset{{Name: "blue git", Size: 9}})
	raw, err := webhook.RenderBody("", rel, nil)
	if err != nil {
		t.Fatal(err)
	}
	var release map[string]any
	if err := json.Unmarshal(raw, &release); err != nil {
		t.Fatal(err)
	}
	info := release["release"].(map[string]any)
	asset := info["assets"].([]any)[0].(map[string]any)
	if info["tag"] != "v1.2.0" || info["name"] != "BlueGit 1.2.0" || info["commit"] != sha || !strings.Contains(asset["url"].(string), "/-/releases/v1.2.0/assets/blue%20git") {
		t.Fatalf("release %s", raw)
	}

	if elapsedSeconds(time.Unix(10, 0), time.Unix(12, 0)) != 2 {
		t.Fatal("duur")
	}

	infoPage := read(t, mustGet(t, tim, ts.URL+"/-/info"))
	for _, want := range []string{"Webhook payloads", "log_truncated", "log_url", "/api/v1/webhooks/openapi.json", "commit_message", "source_branch"} {
		if !strings.Contains(infoPage, want) {
			t.Errorf("infopagina mist %q", want)
		}
	}
	specRes, err := http.Get(ts.URL + "/api/v1/webhooks/openapi.json")
	if err != nil {
		t.Fatal(err)
	}
	spec := read(t, specRes)
	if specRes.StatusCode != 200 || !strings.Contains(spec, `"openapi": "3.1.0"`) || !strings.Contains(spec, "log_truncated") {
		t.Fatalf("spec %d %s", specRes.StatusCode, spec[:min(200, len(spec))])
	}
}

func decodeKind(t *testing.T, bodies [][]byte, kind 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
		}
		if doc["object_kind"] == kind {
			return doc
		}
	}
	t.Fatalf("geen %s in %d payloads", kind, len(bodies))
	return nil
}

func decodeAction(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
		}
		mr, _ := doc["merge_request"].(map[string]any)
		if mr != nil && mr["action"] == action {
			return doc
		}
	}
	t.Fatalf("geen actie %s", action)
	return nil
}

func mustJSON(t *testing.T, v any) string {
	t.Helper()
	b, err := json.Marshal(v)
	if err != nil {
		t.Fatal(err)
	}
	return string(b)
}
