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"
)

func TestSuggestionsAndReadonlyComments(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"},
		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": {"review"}, "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/review.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/review/-/merge-requests")
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/review/-/merge-requests", url.Values{
		"csrf": {csrfOf(t, page)}, "title": {"Hoofdletters"}, "source": {"feature"}, "target": {"master"},
	})
	if err != nil {
		t.Fatal(err)
	}
	opened := read(t, res)
	if !strings.Contains(opened, "BETA") || !strings.Contains(opened, `data-line="2"`) || !strings.Contains(opened, "Apply suggestions") {
		t.Fatalf("diff of toepassen:\n%s", opened)
	}

	ctx := context.Background()
	repo, err := st.RepoByPath(ctx, "tim", "review")
	if err != nil {
		t.Fatal(err)
	}
	bob, err := st.UpsertUser(ctx, 2, "bob", "", false)
	if err != nil {
		t.Fatal(err)
	}
	ada, err := st.UpsertUser(ctx, 3, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	sam, err := st.UpsertUser(ctx, 4, "sam", "", false)
	if err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "bob", "readonly"); err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
		t.Fatal(err)
	}
	bobC := clientAs(t, ts.URL, st, bob.ID)
	adaC := clientAs(t, ts.URL, st, ada.ID)
	samC := clientAs(t, ts.URL, st, sam.ID)

	res, err = samC.Get(ts.URL + "/tim/review/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	samPage := read(t, res)
	if strings.Contains(samPage, `name="body"`) || strings.Contains(samPage, "data-can-comment") {
		t.Fatal("zonder rol is er een reactieformulier")
	}
	res, err = samC.PostForm(ts.URL+"/tim/review/-/merge-requests/1/notes", url.Values{
		"csrf": {csrfOf(t, samPage)}, "body": {"hoort niet"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("sam status %d", res.StatusCode)
	}
	_ = read(t, res)

	res, err = bobC.Get(ts.URL + "/tim/review/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	bobPage := read(t, res)
	if !strings.Contains(bobPage, `data-can-comment="1"`) || !strings.Contains(bobPage, `class="gutter"`) {
		t.Fatal("readonly mist de diffbalk")
	}
	if strings.Contains(bobPage, "data-suggestion") || strings.Contains(bobPage, "Apply suggestions") {
		t.Fatal("readonly kan suggesties aanvinken")
	}
	res, err = bobC.PostForm(ts.URL+"/tim/review/-/merge-requests/1/notes", url.Values{
		"csrf": {csrfOf(t, bobPage)}, "body": {"algemeen"},
	})
	if err != nil {
		t.Fatal(err)
	}
	bobPage = read(t, res)
	if !strings.Contains(bobPage, "algemeen") {
		t.Fatal("algemene reactie ontbreekt")
	}
	res, err = bobC.PostForm(ts.URL+"/tim/review/-/merge-requests/1/notes", url.Values{
		"csrf": {csrfOf(t, bobPage)}, "path": {"hello.txt"}, "line_start": {"2"}, "line_end": {"2"},
		"body": {"```suggestion\nfixed\n```"},
	})
	if err != nil {
		t.Fatal(err)
	}
	bobPage = read(t, res)
	if !strings.Contains(bobPage, "fixed") || strings.Contains(bobPage, "data-suggestion") {
		t.Fatalf("regelreactie:\n%s", bobPage)
	}
	res, err = bobC.PostForm(ts.URL+"/tim/review/-/merge-requests/1/suggestions", url.Values{
		"csrf": {csrfOf(t, bobPage)}, "id": {"2"}, "title": {"mag niet"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("readonly toepassen %d", res.StatusCode)
	}
	_ = read(t, res)

	writeFile(t, filepath.Join(work, "hello.txt"), "alpha\nBETA2\ngamma\n")
	git(t, work, "add", "hello.txt")
	git(t, work, "commit", "-m", "intussen")
	git(t, work, "push", "origin", "feature")

	res, err = adaC.Get(ts.URL + "/tim/review/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	adaPage := read(t, res)
	ids := suggestionIDs(adaPage)
	if len(ids) != 1 {
		t.Fatalf("suggesties %v\n%s", ids, adaPage)
	}
	res, err = adaC.PostForm(ts.URL+"/tim/review/-/merge-requests/1/suggestions", url.Values{
		"csrf": {csrfOf(t, adaPage)}, "id": {ids[0]}, "title": {"te laat"},
	})
	if err != nil {
		t.Fatal(err)
	}
	conflict := read(t, res)
	if !strings.Contains(conflict, "hello.txt:2-2 has changed") {
		t.Fatalf("conflict:\n%s", conflict)
	}

	res, err = bobC.Get(ts.URL + "/tim/review/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	bobPage = read(t, res)
	res, err = bobC.PostForm(ts.URL+"/tim/review/-/merge-requests/1/notes", url.Values{
		"csrf": {csrfOf(t, bobPage)}, "path": {"hello.txt"}, "line_start": {"2"}, "line_end": {"3"},
		"body": {"```suggestion\nfixed\nGAMMA\n```"},
	})
	if err != nil {
		t.Fatal(err)
	}
	_ = read(t, res)

	if err := st.AddProtected(ctx, repo.ID, "feature"); err != nil {
		t.Fatal(err)
	}
	res, err = adaC.Get(ts.URL + "/tim/review/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	adaPage = read(t, res)
	if strings.Contains(adaPage, "data-suggestion") {
		t.Fatal("ontwikkelaar ziet een vakje op een beschermde bronbranch")
	}
	fresh := suggestionIDs(read(t, mustGet(t, tim, ts.URL+"/tim/review/-/merge-requests/1")))
	if len(fresh) != 2 {
		t.Fatalf("beheerder ziet %v", fresh)
	}
	res, err = adaC.PostForm(ts.URL+"/tim/review/-/merge-requests/1/suggestions", url.Values{
		"csrf": {csrfOf(t, adaPage)}, "id": {fresh[1]}, "title": {"van ada"},
	})
	if err != nil {
		t.Fatal(err)
	}
	denied := read(t, res)
	if !strings.Contains(denied, "you cannot push to feature") {
		t.Fatalf("beschermd:\n%s", denied)
	}

	bare := gitrepo.Dir(storage, "tim", "review")
	before := strings.TrimSpace(mustGit(t, bare, "rev-list", "--count", "feature"))
	res, err = tim.Get(ts.URL + "/tim/review/-/merge-requests/1")
	if err != nil {
		t.Fatal(err)
	}
	timPage := read(t, res)
	res, err = tim.PostForm(ts.URL+"/tim/review/-/merge-requests/1/suggestions", url.Values{
		"csrf": {csrfOf(t, timPage)}, "id": {fresh[1]}, "title": {"Suggestie van bob"}, "description": {"twee regels"},
	})
	if err != nil {
		t.Fatal(err)
	}
	applied := read(t, res)
	if !strings.Contains(applied, "Suggestions applied") {
		t.Fatalf("toepassen:\n%s", applied)
	}
	body := mustGit(t, bare, "show", "feature:hello.txt")
	if body != "alpha\nfixed\nGAMMA\n" {
		t.Fatalf("bestand %q", body)
	}
	after := strings.TrimSpace(mustGit(t, bare, "rev-list", "--count", "feature"))
	msg := mustGit(t, bare, "log", "-1", "--format=%s%n%b", "feature")
	who := mustGit(t, bare, "log", "-1", "--format=%ae", "feature")
	if after != bumpCount(before) || !strings.Contains(msg, "Suggestie van bob") || !strings.Contains(msg, "twee regels") || strings.TrimSpace(who) != "tim@users.git.timfalken.com" {
		t.Fatalf("voor %s na %s\n%s", before, after, msg)
	}
}

func bumpCount(n string) string {
	i := 0
	for _, c := range n {
		i = i*10 + int(c-'0')
	}
	return strconvItoa(i + 1)
}

func strconvItoa(n int) string {
	if n == 0 {
		return "0"
	}
	var b [16]byte
	i := len(b)
	for n > 0 {
		i--
		b[i] = byte('0' + n%10)
		n /= 10
	}
	return string(b[i:])
}

func clientAs(t *testing.T, base string, st *store.Store, userID int64) *http.Client {
	t.Helper()
	sess, err := st.CreateSession(context.Background(), userID, "dev", time.Now().Add(time.Hour))
	if err != nil {
		t.Fatal(err)
	}
	jar, _ := cookiejar.New(nil)
	u, _ := url.Parse(base)
	jar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
	return &http.Client{Jar: jar}
}

func mustGit(t *testing.T, dir string, args ...string) string {
	t.Helper()
	out, err := gitOut(dir, args...)
	if err != nil {
		t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
	}
	return out
}

func mustGet(t *testing.T, c *http.Client, raw string) *http.Response {
	t.Helper()
	res, err := c.Get(raw)
	if err != nil {
		t.Fatal(err)
	}
	return res
}

func suggestionIDs(html string) []string {
	var out []string
	const needle = `data-suggestion="`
	for {
		i := strings.Index(html, needle)
		if i < 0 {
			break
		}
		html = html[i+len(needle):]
		j := strings.Index(html, `"`)
		out = append(out, html[:j])
		html = html[j:]
	}
	return out
}
