package server

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

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

const receiveYML = "stages:\n  - test\nunit:\n  stage: test\n  image: alpine:3.20\n  script:\n    - echo ok\n"

func TestPostReceiveStartsPipeline(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"},
		CI:   config.CI{Enabled: true, Docker: "docker"},
	}
	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)
	tim := &http.Client{Jar: jar}
	res, err := tim.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	page := read(t, res)
	res, err = tim.PostForm(ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"ontvangen"}, "visibility": {"public"},
	})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "ontvangen")
	if err != nil {
		t.Fatal(err)
	}
	user, err := st.UserByUsername(ctx, "tim")
	if err != nil {
		t.Fatal(err)
	}
	hookID, err := st.CreateWebhook(ctx, store.Webhook{
		ScopeKind: "repo", ScopeID: repo.ID, Name: "push", Preset: "generic",
		URLTemplate: "http://127.0.0.1:9/hook", Events: []string{"push"},
	})
	if err != nil {
		t.Fatal(err)
	}
	res, err = tim.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/ontvangen.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"), "hallo\n")
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "leesmij")
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")

	if n := pipelineCount(t, st, repo.ID); n != 0 {
		t.Fatalf("readme zonder yml startte %d pipelines", n)
	}
	pushes := pushDeliveries(t, st, hookID)
	acts := contribCount(t, st, user.ID, repo.ID)
	if pushes < 1 || acts < 1 {
		t.Fatalf("git push: webhooks %d activity %d", pushes, acts)
	}

	res, err = tim.Get(ts.URL + "/tim/ontvangen/-/ci/editor?ref=master")
	if err != nil {
		t.Fatal(err)
	}
	editor := read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/ci/editor", url.Values{
		"csrf": {csrfOf(t, editor)}, "base": {"master"}, "branch": {"master"},
		"message": {"voeg blue-ci-cd.yml toe"}, "body": {receiveYML},
	})
	if err != nil {
		t.Fatal(err)
	}
	if saved := read(t, res); !strings.Contains(saved, "Committed.") {
		t.Fatalf("editor:\n%s", saved)
	}
	dir := gitrepo.Dir(storage, "tim", "ontvangen")
	master := strings.TrimSpace(mustGit(t, dir, "rev-parse", "refs/heads/master"))
	pipe := pipelineFor(t, st, repo.ID, master, "refs/heads/master")
	if pipe.Source != "push" || pipe.Status != "queued" {
		t.Fatalf("editor-pipeline: %+v", pipe)
	}
	if jobs, err := st.JobsByPipeline(ctx, pipe.ID); err != nil || len(jobs) != 1 || jobs[0].Name != "unit" || jobs[0].Status != "queued" {
		t.Fatalf("editor-jobs: %v %+v", err, jobs)
	}
	if pushDeliveries(t, st, hookID) < pushes+1 {
		t.Fatal("editor startte geen webhook")
	}
	if contribCount(t, st, user.ID, repo.ID) < acts+1 {
		t.Fatal("editor startte geen activity")
	}
	pushes = pushDeliveries(t, st, hookID)
	acts = contribCount(t, st, user.ID, repo.ID)

	list := read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen/-/pipelines"))
	for _, want := range []string{`data-live-on="1"`, `class="stage-dot pending"`, "Pending"} {
		if !strings.Contains(list, want) {
			t.Errorf("lijst mist %q", want)
		}
	}
	home := read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen"))
	if !strings.Contains(home, `class="status pending"`) || !strings.Contains(home, "Pending") {
		t.Fatalf("overzicht mist pending:\n%s", home)
	}
	css := read(t, mustGet(t, tim, ts.URL+"/assets/style.css"))
	for _, want := range []string{"@keyframes spin", ".stage-dot.pending .mark", "border-right-color: transparent"} {
		if !strings.Contains(css, want) {
			t.Errorf("css mist %q", want)
		}
	}

	jobs, err := st.JobsByPipeline(ctx, pipe.ID)
	if err != nil {
		t.Fatal(err)
	}
	if ok, err := st.MarkJobRunning(ctx, jobs[0].ID); err != nil || !ok {
		t.Fatalf("running: %v %v", ok, err)
	}
	home = read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen"))
	if !strings.Contains(home, `class="status running"`) || !strings.Contains(home, "Running") {
		t.Fatalf("overzicht mist running:\n%s", home)
	}
	list = read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen/-/pipelines"))
	if !strings.Contains(list, `class="stage-dot running"`) || !strings.Contains(list, `class="status running"`) {
		t.Fatal("lijst mist het lopende icoon")
	}

	res, err = tim.Get(ts.URL + "/tim/ontvangen/-/tags")
	if err != nil {
		t.Fatal(err)
	}
	tags := read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/tags", url.Values{
		"csrf": {csrfOf(t, tags)}, "name": {"v1"}, "target": {"master"}, "message": {"eerste"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if page = read(t, res); !strings.Contains(page, "v1") {
		t.Fatalf("tag:\n%s", page)
	}
	tagged := pipelineFor(t, st, repo.ID, master, "refs/tags/v1")
	if tagged.Status != "queued" {
		t.Fatalf("tag-pipeline: %+v", tagged)
	}
	if pushDeliveries(t, st, hookID) < pushes+1 || contribCount(t, st, user.ID, repo.ID) < acts+1 {
		t.Fatal("tag mist webhook of activity")
	}

	res, err = tim.Get(ts.URL + "/tim/ontvangen/-/ci/editor?ref=master")
	if err != nil {
		t.Fatal(err)
	}
	editor = read(t, res)
	featureYML := strings.Replace(receiveYML, "echo ok", "echo feature", 1)
	res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/ci/editor", url.Values{
		"csrf": {csrfOf(t, editor)}, "base": {"master"}, "branch": {"feature"},
		"message": {"feature yml"}, "body": {featureYML},
	})
	if err != nil {
		t.Fatal(err)
	}
	if saved := read(t, res); !strings.Contains(saved, "Committed.") {
		t.Fatalf("feature:\n%s", saved)
	}
	feature := strings.TrimSpace(mustGit(t, dir, "rev-parse", "refs/heads/feature"))
	_ = pipelineFor(t, st, repo.ID, feature, "refs/heads/feature")

	res, err = tim.Get(ts.URL + "/tim/ontvangen/-/merge-requests")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"feature"}, "source": {"feature"}, "target": {"master"},
	})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/merge-requests/1/notes", url.Values{
		"csrf": {csrfOf(t, page)}, "path": {"blue-ci-cd.yml"}, "line_start": {"7"}, "line_end": {"7"},
		"body": {"```suggestion\n    - echo toegepast\n```"},
	})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	ids := suggestionIDs(page)
	if len(ids) != 1 {
		t.Fatalf("suggestie-ids %v", ids)
	}
	beforeFeature := feature
	res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/merge-requests/1/suggestions", url.Values{
		"csrf": {csrfOf(t, page)}, "id": {ids[0]}, "title": {"pas de regel aan"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if applied := read(t, res); !strings.Contains(applied, "Suggestions applied") {
		t.Fatalf("suggestie:\n%s", applied)
	}
	feature = strings.TrimSpace(mustGit(t, dir, "rev-parse", "refs/heads/feature"))
	if feature == beforeFeature {
		t.Fatal("suggestie maakte geen commit")
	}
	_ = pipelineFor(t, st, repo.ID, feature, "refs/heads/feature")

	if err := st.UpsertReview(ctx, repo.ID, 1, user.ID, "approved"); err != nil {
		t.Fatal(err)
	}
	passPipelines(t, st, repo.ID)
	res, err = tim.Get(ts.URL + "/tim/ontvangen/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/ontvangen/-/merge-requests/1/merge", url.Values{"csrf": {csrfOf(t, page)}})
	if err != nil {
		t.Fatal(err)
	}
	if merged := read(t, res); !strings.Contains(merged, "Merged") && !strings.Contains(merged, "samengevoegd") && !strings.Contains(merged, "merged") {
		t.Fatalf("merge:\n%s", merged)
	}
	mergedSHA := strings.TrimSpace(mustGit(t, dir, "rev-parse", "refs/heads/master"))
	if mergedSHA == master {
		t.Fatal("merge verschoof master niet")
	}
	_ = pipelineFor(t, st, repo.ID, mergedSHA, "refs/heads/master")
	passPipelines(t, st, repo.ID)

	quiet := read(t, mustGet(t, tim, ts.URL+"/tim/ontvangen/-/pipelines"))
	if strings.Contains(quiet, `data-live-on="1"`) {
		t.Fatal("afgeronde lijst blijft pollen")
	}
}

func pipelineCount(t *testing.T, st *store.Store, repoID int64) int {
	t.Helper()
	pipes, err := st.ListPipelines(context.Background(), repoID)
	if err != nil {
		t.Fatal(err)
	}
	return len(pipes)
}

func pipelineFor(t *testing.T, st *store.Store, repoID int64, sha, ref string) store.Pipeline {
	t.Helper()
	pipes, err := st.ListPipelines(context.Background(), repoID)
	if err != nil {
		t.Fatal(err)
	}
	for _, p := range pipes {
		if p.CommitSHA == sha && p.Ref == ref {
			return p
		}
	}
	t.Fatalf("geen pipeline voor %s %s in %d stuks", ref, sha, len(pipes))
	return store.Pipeline{}
}

func pushDeliveries(t *testing.T, st *store.Store, hookID int64) int {
	t.Helper()
	rows, err := st.RecentDeliveries(context.Background(), hookID)
	if err != nil {
		t.Fatal(err)
	}
	n := 0
	for _, row := range rows {
		if row.EventType == "push" {
			n++
		}
	}
	return n
}

func contribCount(t *testing.T, st *store.Store, userID, repoID int64) int {
	t.Helper()
	times, err := st.ContributionTimes(context.Background(), userID, []int64{repoID}, time.Unix(0, 0))
	if err != nil {
		t.Fatal(err)
	}
	return len(times)
}

func passPipelines(t *testing.T, st *store.Store, repoID int64) {
	t.Helper()
	ctx := context.Background()
	pipes, err := st.ListPipelines(ctx, repoID)
	if err != nil {
		t.Fatal(err)
	}
	for _, p := range pipes {
		jobs, err := st.JobsByPipeline(ctx, p.ID)
		if err != nil {
			t.Fatal(err)
		}
		for _, j := range jobs {
			if j.Status == "success" || j.Status == "failed" || j.Status == "canceled" || j.Status == "skipped" {
				continue
			}
			if err := st.FinishJob(ctx, j.ID, "success", ""); err != nil {
				t.Fatal(err)
			}
		}
		if _, err := st.RefreshPipelineStatus(ctx, p.ID); err != nil {
			t.Fatal(err)
		}
	}
}
