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 TestForceMergeDespiteDraft(t *testing.T) {
	srv, ts, st := mergeFixServer(t)
	_ = srv
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)
	work := pushPair(t, ts, token, "forcey", "alpha\n", "beta\n")
	page := read(t, mustGet(t, tim, ts.URL+"/tim/forcey/-/merge-requests/new?source=topic&target=master"))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/forcey/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Concept"}, "description": {"Closes #9"},
		"source": {"topic"}, "target": {"master"}, "draft": {"1"},
	}))
	if !strings.Contains(page, "This merge request is a draft.") || !strings.Contains(page, "Merge anyway") || !strings.Contains(page, "cannot be merged yet") {
		t.Fatalf("reden ontbreekt:\n%s", page)
	}
	if strings.Contains(page, `>{{t "action.merge"}}`) {
		t.Fatal("gewone mergeknop")
	}
	stayed := read(t, mustPost(t, tim, ts.URL+"/tim/forcey/-/merge-requests/1/merge", url.Values{
		"csrf": {csrfOf(t, page)}, "force": {"1"},
	}))
	if !strings.Contains(stayed, "Confirm that you want to merge anyway.") {
		t.Fatalf("zonder bevestiging:\n%s", stayed)
	}
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "forcey")
	if err != nil {
		t.Fatal(err)
	}
	mr, err := st.MergeRequestByNumber(ctx, repo.ID, 1)
	if err != nil || mr.Status != "open" {
		t.Fatalf("status %s %v", mr.Status, err)
	}
	merged := read(t, mustPost(t, tim, ts.URL+"/tim/forcey/-/merge-requests/1/merge", url.Values{
		"csrf": {csrfOf(t, stayed)}, "force": {"1"}, "confirm_force": {"1"},
	}))
	if !strings.Contains(merged, "merged anyway") || !strings.Contains(merged, "This merge request is a draft.") {
		t.Fatalf("activiteit:\n%s", merged)
	}
	mr, err = st.MergeRequestByNumber(ctx, repo.ID, 1)
	if err != nil || mr.Status != "merged" {
		t.Fatalf("na toch mergen: %s %v", mr.Status, err)
	}
	_ = work
}

func TestPushMarksMergeRequestMerged(t *testing.T) {
	_, ts, st := mergeFixServer(t)
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)
	work := pushPair(t, ts, token, "hand", "een\n", "twee\n")
	page := read(t, mustGet(t, tim, ts.URL+"/tim/hand/-/merge-requests/new?source=topic&target=master"))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/hand/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Handmatig"}, "source": {"topic"}, "target": {"master"},
	}))
	if !strings.Contains(page, ">open<") && !strings.Contains(page, "open") {
		t.Fatalf("open:\n%s", page)
	}
	git(t, work, "checkout", "master")
	git(t, work, "merge", "--no-edit", "topic")
	git(t, work, "push", "origin", "master")
	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "hand")
	if err != nil {
		t.Fatal(err)
	}
	mr, err := st.MergeRequestByNumber(ctx, repo.ID, 1)
	if err != nil || mr.Status != "merged" {
		t.Fatalf("push hoort de MR merged te zetten: %s %v", mr.Status, err)
	}
	shown := read(t, mustGet(t, tim, ts.URL+"/tim/hand/-/merge-requests/1"))
	if !strings.Contains(shown, "merged this merge request") {
		t.Fatalf("tijdlijn:\n%s", shown)
	}
	branches := read(t, mustGet(t, tim, ts.URL+"/tim/hand/-/branches"))
	if strings.Contains(branches, "/-/merge-requests/1") {
		t.Fatalf("gemergde MR hoort niet meer in de kolom:\n%s", branches)
	}
}

func TestMergeShowsConflict(t *testing.T) {
	_, ts, _ := mergeFixServer(t)
	tim := loginClient(t, ts)
	token := mintToken(t, tim, ts)
	work := pushPair(t, ts, token, "bots", "zelfde\n", "links\n")
	git(t, work, "checkout", "master")
	writeFile(t, filepath.Join(work, "hello.txt"), "rechts\n")
	git(t, work, "add", "hello.txt")
	git(t, work, "commit", "-m", "master wijzigt")
	git(t, work, "push", "origin", "master")
	page := read(t, mustGet(t, tim, ts.URL+"/tim/bots/-/merge-requests/new?source=topic&target=master"))
	page = read(t, mustPost(t, tim, ts.URL+"/tim/bots/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Bots"}, "source": {"topic"}, "target": {"master"},
	}))
	if !strings.Contains(page, "The branches conflict.") || !strings.Contains(page, "Merge anyway") {
		t.Fatalf("conflict:\n%s", page)
	}
	tried := read(t, mustPost(t, tim, ts.URL+"/tim/bots/-/merge-requests/1/merge", url.Values{
		"csrf": {csrfOf(t, page)}, "force": {"1"}, "confirm_force": {"1"},
	}))
	if !strings.Contains(tried, "conflict") || !strings.Contains(tried, ">open<") && !strings.Contains(tried, "open") {
		t.Fatalf("toch mergen bij een conflict:\n%s", tried)
	}
}

func mergeFixServer(t *testing.T) (*Server, *httptest.Server, *store.Store) {
	t.Helper()
	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)
	return srv, ts, st
}

func loginClient(t *testing.T, ts *httptest.Server) *http.Client {
	t.Helper()
	jar, _ := cookiejar.New(nil)
	tim := &http.Client{Jar: jar}
	read(t, mustGet(t, tim, ts.URL+"/login"))
	return tim
}

func mintToken(t *testing.T, tim *http.Client, ts *httptest.Server) string {
	t.Helper()
	page := read(t, mustGet(t, tim, ts.URL+"/settings"))
	page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"laptop"},
	}))
	return between(page, `<p class="code">`, "</p>")
}

func pushPair(t *testing.T, ts *httptest.Server, token, name, base, next string) string {
	t.Helper()
	page := read(t, mustGet(t, loginOwner(t, ts), ts.URL+"/new/repo"))
	_ = page
	tim := loginOwner(t, ts)
	home := read(t, mustGet(t, tim, ts.URL+"/"))
	_ = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, home)}, "name": {name}, "visibility": {"public"},
	}))
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/" + name + ".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"), base)
	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", "topic")
	writeFile(t, filepath.Join(work, "hello.txt"), next)
	git(t, work, "add", "hello.txt")
	git(t, work, "commit", "-m", "verder")
	git(t, work, "push", "-u", "origin", "topic")
	return work
}

func loginOwner(t *testing.T, ts *httptest.Server) *http.Client {
	t.Helper()
	return loginClient(t, ts)
}
