package server

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

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

func TestWebRepoPushAndSecretBoundary(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	storage := t.TempDir()
	key := bytes32()
	st, err := store.Open(filepath.Join(storage, "bluegit.db"), key)
	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"},
		SSH:  config.SSH{Enabled: true, Listen: "0.0.0.0:2222", PublicHost: "git.timfalken.com", PublicPort: 22},
		CI:   config.CI{Enabled: false},
	}
	cfg.Auth.BaseURL = "https://auth.timfalken.com"
	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)
	client := &http.Client{Jar: jar}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	body := read(t, res)
	if res.StatusCode != 200 || !strings.Contains(body, "Overzicht") {
		t.Fatalf("login %d %s", res.StatusCode, body)
	}
	logo, err := client.Get(ts.URL + "/assets/logo.svg")
	if err != nil {
		t.Fatal(err)
	}
	if logo.StatusCode != 200 || !strings.Contains(read(t, logo), "<svg") {
		t.Fatalf("logo %d", logo.StatusCode)
	}
	csrf := csrfOf(t, body)
	form := url.Values{"csrf": {csrf}, "name": {"demo"}, "description": {"eerste"}, "visibility": {"private"}}
	res, err = client.PostForm(ts.URL+"/new/repo", form)
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, "tim/demo") {
		t.Fatalf("repo pagina:\n%s", body)
	}
	if !strings.Contains(body, "ssh://git@git.timfalken.com:22/tim/demo.git") {
		t.Fatalf("clone-URL hoort de publieke SSH-poort te tonen:\n%s", body)
	}
	if strings.Contains(body, ":2222/") {
		t.Fatalf("clone-URL toont de bindpoort:\n%s", body)
	}

	res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{"csrf": {csrfOf(t, body)}, "name": {"test"}})
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	token := between(body, `<p class="code">`, "</p>")
	if !strings.HasPrefix(token, "bg_") {
		t.Fatalf("token pagina:\n%s", body)
	}

	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")
	if err := os.WriteFile(filepath.Join(work, "README.md"), []byte("hallo bluegit\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	git(t, work, "add", "README.md")
	git(t, work, "commit", "-m", "eerste commit")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/demo.git"
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")

	res, err = client.Get(ts.URL + "/tim/demo")
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, "eerste commit") || !strings.Contains(body, "README.md") {
		t.Fatalf("na push:\n%s", body)
	}
	res, err = client.Get(ts.URL + "/tim/demo/-/blob/README.md")
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if !strings.Contains(body, "hallo bluegit") {
		t.Fatalf("blob:\n%s", body)
	}

	ctx := context.Background()
	ada, err := st.UpsertUser(ctx, 2, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	repo, err := st.RepoByPath(ctx, "tim", "demo")
	if err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "repo", repo.ID, "ada", "developer"); err != nil {
		t.Fatal(err)
	}
	sess, err := st.CreateSession(ctx, ada.ID, "dev", time.Now().Add(time.Hour))
	if err != nil {
		t.Fatal(err)
	}
	adaJar, _ := cookiejar.New(nil)
	adaClient := &http.Client{Jar: adaJar}
	u, _ := url.Parse(ts.URL)
	adaJar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
	res, err = adaClient.Get(ts.URL + "/")
	if err != nil {
		t.Fatal(err)
	}
	adaCSRF := csrfOf(t, read(t, res))
	res, err = adaClient.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
		"csrf": {adaCSRF}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("ontwikkelaar mocht een geheim schrijven: %d", res.StatusCode)
	}
	_ = res.Body.Close()

	res, err = client.Get(ts.URL + "/tim/demo/-/settings?tab=geheimen")
	if err != nil {
		t.Fatal(err)
	}
	ownerPage := read(t, res)
	res, err = client.PostForm(ts.URL+"/tim/demo/-/secrets", url.Values{
		"csrf": {csrfOf(t, ownerPage)}, "name": {"TOKEN"}, "value": {"super-geheim-waarde"},
	})
	if err != nil {
		t.Fatal(err)
	}
	saved := read(t, res)
	if strings.Contains(saved, "super-geheim-waarde") {
		t.Fatal("geheimwaarde staat op de pagina")
	}
	if !strings.Contains(saved, "TOKEN") {
		t.Fatalf("naam ontbreekt:\n%s", saved)
	}

	res, err = client.PostForm(ts.URL+"/tim/demo/-/webhooks", url.Values{
		"csrf": {csrfOf(t, saved)}, "name": {"kapot"}, "preset": {"generic"},
		"url": {"https://example.test/hook"}, "branch_filter": {"re:("}, "event_push": {"1"},
	})
	if err != nil {
		t.Fatal(err)
	}
	hookPage := read(t, res)
	if !strings.Contains(hookPage, "branchfilter") && !strings.Contains(hookPage, "error") && !strings.Contains(strings.ToLower(hookPage), "regex") {
		t.Fatalf("kapot filter:\n%s", hookPage)
	}
}

func csrfOf(t *testing.T, body string) string {
	t.Helper()
	const needle = `name="csrf" value="`
	i := strings.Index(body, needle)
	if i < 0 {
		t.Fatalf("geen csrf in\n%s", body)
	}
	rest := body[i+len(needle):]
	j := strings.Index(rest, `"`)
	return rest[:j]
}

func between(s, a, b string) string {
	i := strings.Index(s, a)
	if i < 0 {
		return ""
	}
	rest := s[i+len(a):]
	j := strings.Index(rest, b)
	if j < 0 {
		return ""
	}
	return rest[:j]
}

func read(t *testing.T, res *http.Response) string {
	t.Helper()
	defer res.Body.Close()
	b, err := io.ReadAll(res.Body)
	if err != nil {
		t.Fatal(err)
	}
	return string(b)
}

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

func bytes32() []byte {
	b := make([]byte, 32)
	for i := range b {
		b[i] = byte(i + 3)
	}
	return b
}
