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

func TestReviewsApprovalsAndReopen(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"},
	}
	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": {"gates"}, "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/gates.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, "hello.txt"), "alpha\nbeta\ngamma\n")
	git(t, work, "add", "hello.txt")
	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", "feature")
	writeFile(t, filepath.Join(work, "hello.txt"), "alpha\nBETA\ngamma\n")
	git(t, work, "add", "hello.txt")
	git(t, work, "commit", "-m", "hoofdletters")
	git(t, work, "push", "-u", "origin", "feature")

	res, err = tim.Get(ts.URL + "/tim/gates/-/merge-requests")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/gates/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Hoofdletters"}, "source": {"feature"}, "target": {"master"},
	})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)

	res, err = tim.Get(ts.URL + "/tim/gates/-/settings?tab=approvals")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/gates/-/approvals", url.Values{
		"csrf": {csrfOf(t, page)}, "maintainer_required": {"1"}, "required_count": {"3"},
	})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if !strings.Contains(page, "This requires 3 approvals, and there is 1 maintainer.") {
		t.Fatalf("waarschuwing:\n%s", page)
	}
	res, err = tim.PostForm(ts.URL+"/settings/language", url.Values{"csrf": {csrfOf(t, page)}, "language": {"nl"}})
	if err != nil {
		t.Fatal(err)
	}
	_ = read(t, res)
	res, err = tim.Get(ts.URL + "/tim/gates/-/settings?tab=approvals")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	for _, want := range []string{
		"Dit vraagt 3 goedkeuringen, en er is 1 beheerder.",
		"Vereiste goedkeuringen",
		"Goedkeuring van een beheerder vereist",
	} {
		if !strings.Contains(page, want) {
			t.Fatalf("nl mist %q:\n%s", want, page)
		}
	}
	if strings.Contains(page, "Vereiste approvals") || strings.Contains(page, "Maintainer-approval") {
		t.Fatalf("nl houdt het Engelse woord:\n%s", page)
	}
	res, err = tim.PostForm(ts.URL+"/settings/language", url.Values{"csrf": {csrfOf(t, page)}, "language": {"en"}})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)

	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "gates")
	if err != nil {
		t.Fatal(err)
	}
	ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	bob, err := st.UpsertUser(ctx, 3, "bob", "", false)
	if err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "ada", access.RoleMaintainer); err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "bob", access.RoleReadonly); err != nil {
		t.Fatal(err)
	}
	if err := st.SaveApproval(ctx, "repo", repo.ID, store.ApprovalPolicy{MaintainerRequired: true, RequiredCount: 1}); err != nil {
		t.Fatal(err)
	}
	if mrPage := read(t, mustGet(t, tim, ts.URL+"/tim/gates/-/merge-requests/1")); !strings.Contains(mrPage, "0 of 1 approval.") {
		t.Fatalf("enkelvoud:\n%s", mrPage)
	}

	res, err = tim.PostForm(ts.URL+"/tim/gates/-/merge-requests/1/reviews", url.Values{"csrf": {csrfOf(t, page)}, "status": {"approved"}})
	if err != nil {
		t.Fatal(err)
	}
	if body := read(t, res); !strings.Contains(body, "You cannot approve your own merge request.") {
		t.Fatalf("eigen approval:\n%s", body)
	}

	adaC := clientAs(t, ts.URL, st, ada.ID)
	res, err = adaC.Get(ts.URL + "/tim/gates/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	adaPage := read(t, res)
	res, err = adaC.PostForm(ts.URL+"/tim/gates/-/merge-requests/1/reviews", url.Values{"csrf": {csrfOf(t, adaPage)}, "status": {"approved"}})
	if err != nil {
		t.Fatal(err)
	}
	if body := read(t, res); !strings.Contains(body, "1 of 1 approvals") && strings.Contains(body, "approvals.") {
		t.Fatalf("na ada:\n%s", body)
	}
	body := read(t, mustGet(t, adaC, ts.URL+"/tim/gates/-/merge-requests/1"))
	if strings.Contains(body, "of 1 approvals") {
		t.Fatalf("ada's approval hoort te volstaan:\n%s", body)
	}

	bobC := clientAs(t, ts.URL, st, bob.ID)
	res, err = bobC.Get(ts.URL + "/tim/gates/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	bobPage := read(t, res)
	res, err = bobC.PostForm(ts.URL+"/tim/gates/-/merge-requests/1/notes", url.Values{
		"csrf": {csrfOf(t, bobPage)}, "path": {"hello.txt"}, "line_start": {"2"}, "line_end": {"2"},
		"body": {"beter\n```suggestion\nbetter\n```"},
	})
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, "bob requested changes.") {
		t.Fatalf("suggestie blokkeert:\n%s", body)
	}
	res, err = tim.Get(ts.URL + "/tim/gates/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	if !strings.Contains(page, "disabled") {
		t.Fatalf("mergeknop hoort uit:\n%s", page)
	}
	bobID := ""
	if i := strings.Index(page, `name="user_id" value="`); i >= 0 {
		rest := page[i+len(`name="user_id" value="`):]
		bobID = rest[:strings.Index(rest, `"`)]
	}
	if bobID == "" {
		t.Fatalf("dismiss-knop:\n%s", page)
	}
	res, err = tim.PostForm(ts.URL+"/tim/gates/-/merge-requests/1/reviews/dismiss", url.Values{
		"csrf": {csrfOf(t, page)}, "user_id": {bobID},
	})
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if strings.Contains(body, "bob requested changes.") || strings.Contains(body, "disabled") {
		t.Fatalf("na ongeldig verklaren:\n%s", body)
	}
	if !strings.Contains(body, "Invalidated") {
		t.Fatalf("status:\n%s", body)
	}

	res, err = adaC.PostForm(ts.URL+"/tim/gates/-/merge-requests/1/reviews", url.Values{"csrf": {csrfOf(t, body)}, "status": {"rejected"}})
	if err != nil {
		t.Fatal(err)
	}
	// ada's csrf from an old page may fail. Use a fresh page.
	_ = read(t, res)
	res, err = adaC.Get(ts.URL + "/tim/gates/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	adaPage = read(t, res)
	res, err = adaC.PostForm(ts.URL+"/tim/gates/-/merge-requests/1/reviews", url.Values{"csrf": {csrfOf(t, adaPage)}, "status": {"rejected"}})
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, "ada rejected this merge request.") {
		t.Fatalf("veto:\n%s", body)
	}

	res, err = tim.PostForm(ts.URL+"/tim/gates/-/merge-requests/1/close", url.Values{"csrf": {csrfOf(t, page)}})
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, ">closed<") && !strings.Contains(body, "closed") {
		t.Fatalf("sluiten:\n%s", body)
	}
	if !strings.Contains(body, "Reopen") {
		t.Fatalf("heropenen:\n%s", body)
	}
	res, err = tim.Get(ts.URL + "/tim/gates/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/gates/-/merge-requests/1/reopen", url.Values{"csrf": {csrfOf(t, page)}})
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, ">open<") && !strings.Contains(body, "pill\">open") {
		t.Fatalf("heropend:\n%s", body)
	}
}
