package server

import (
	"context"
	"net/http"
	"net/http/cookiejar"
	"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/store"
)

func TestMergeRequestPipelineBlocksUntilFinished(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": {"mrpipes"}, "visibility": {"public"}})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	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/mrpipes.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")
	yml := `stages: [test]
push_job:
  stage: test
  image: alpine:3.20
  script: ["echo push"]
mr_job:
  stage: test
  image: alpine:3.20
  script: ["echo mr"]
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
soft:
  stage: test
  image: alpine:3.20
  script: ["echo soft"]
  allow_failure: true
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
`
	writeFile(t, filepath.Join(work, "blue-ci-cd.yml"), yml)
	git(t, work, "add", "blue-ci-cd.yml")
	git(t, work, "commit", "-m", "ci")
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")
	git(t, work, "checkout", "-b", "feature")
	writeFile(t, filepath.Join(work, "README.md"), "feature\n")
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "feature")
	git(t, work, "push", "-u", "origin", "feature")

	res, err = tim.Get(ts.URL + "/tim/mrpipes/-/merge-requests")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/mrpipes/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"voeg samen"}, "source": {"feature"}, "target": {"master"},
	})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if !strings.Contains(page, "mr_job") || !strings.Contains(page, "soft") || strings.Contains(page, "push_job") {
		t.Fatalf("mr-pipeline op de pagina:\n%s", page)
	}
	if !strings.Contains(page, "The pipeline is still running.") || !strings.Contains(page, "disabled") {
		t.Fatalf("merge hoort geblokkeerd:\n%s", page)
	}

	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "mrpipes")
	if err != nil {
		t.Fatal(err)
	}
	pipes, err := st.ListPipelines(ctx, repo.ID)
	if err != nil {
		t.Fatal(err)
	}
	var mrPipe store.Pipeline
	pushNames := map[string]bool{}
	for _, p := range pipes {
		jobs, err := st.JobsByPipeline(ctx, p.ID)
		if err != nil {
			t.Fatal(err)
		}
		if p.Source == "push" {
			for _, j := range jobs {
				pushNames[j.Name] = true
			}
			continue
		}
		if p.Source == "merge_request_event" && (mrPipe.ID == 0 || p.ID > mrPipe.ID) {
			mrPipe = p
		}
	}
	if pushNames["mr_job"] || pushNames["soft"] || !pushNames["push_job"] {
		t.Fatalf("push-jobs: %v", pushNames)
	}
	if mrPipe.ID == 0 || mrPipe.MRID == 0 {
		t.Fatalf("mr-pipeline: %+v", mrPipe)
	}
	res, err = tim.PostForm(ts.URL+"/tim/mrpipes/-/merge-requests/1/merge", url.Values{"csrf": {csrfOf(t, page)}})
	if err != nil {
		t.Fatal(err)
	}
	if body := read(t, res); !strings.Contains(body, "The pipeline is still running.") || !strings.Contains(body, ">open<") && !strings.Contains(body, "open") {
		t.Fatalf("merge tijdens de run:\n%s", body)
	}
	mr, err := st.MergeRequestByNumber(ctx, repo.ID, 1)
	if err != nil || mr.Status != "open" {
		t.Fatalf("status %v %v", mr.Status, err)
	}

	jobs, _ := st.JobsByPipeline(ctx, mrPipe.ID)
	for _, j := range jobs {
		if j.Name == "mr_job" {
			if err := st.FinishJob(ctx, j.ID, "success", "mr ok\n"); err != nil {
				t.Fatal(err)
			}
		}
	}
	res, err = tim.Get(ts.URL + "/tim/mrpipes/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	if body := read(t, res); !strings.Contains(body, "The pipeline is still running.") {
		t.Fatalf("allow_failure loopt nog:\n%s", body)
	}
	jobs, _ = st.JobsByPipeline(ctx, mrPipe.ID)
	for _, j := range jobs {
		if j.Name == "soft" {
			if err := st.FinishJob(ctx, j.ID, "failed", "zacht\n"); err != nil {
				t.Fatal(err)
			}
		}
	}
	if _, err := st.RefreshPipelineStatus(ctx, mrPipe.ID); err != nil {
		t.Fatal(err)
	}
	res, err = tim.Get(ts.URL + "/tim/mrpipes/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if strings.Contains(page, "The pipeline is still running.") || strings.Contains(page, "disabled") {
		t.Fatalf("merge hoort open:\n%s", page)
	}
	if !strings.Contains(page, "Warning") && !strings.Contains(page, "Passed") {
		t.Fatalf("status na allow_failure:\n%s", page)
	}

	git(t, work, "checkout", "master")
	writeFile(t, filepath.Join(work, "README.md"), "target\n")
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "target")
	git(t, work, "push", "origin", "master")
	pipes, err = st.ListPipelines(ctx, repo.ID)
	if err != nil {
		t.Fatal(err)
	}
	var newest int64
	for _, p := range pipes {
		if p.Source == "merge_request_event" && p.ID > newest {
			newest = p.ID
			if p.CommitSHA == mrPipe.CommitSHA && p.MRID == mrPipe.MRID {
				continue
			}
			t.Fatalf("nieuwe mr-pipeline hoort op de broncommit: %+v", p)
		}
	}
	if newest <= mrPipe.ID {
		t.Fatalf("push naar de doelbranch start geen nieuwe mr-pipeline: %d", newest)
	}
}
