package server

import (
	"bytes"
	"compress/gzip"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
	"net/http"
	"net/http/cookiejar"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"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 TestGzipSmartHTTP(t *testing.T) {
	if why := gitHTTPGap(); why != "" {
		t.Skip(why)
	}
	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)
	client := &http.Client{Jar: jar}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	page := read(t, res)
	res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"pakket"}, "visibility": {"public"},
	})
	if err != nil {
		t.Fatal(err)
	}
	page = read(t, res)
	res, err = client.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>")
	if !strings.HasPrefix(token, "bg_") {
		t.Fatal("geen token")
	}

	bare := gitrepo.Dir(storage, "tim", "pakket")
	work := t.TempDir()
	gitPrep(t, work)
	writeFile(t, filepath.Join(work, "leesmij.txt"), "hallo\n")
	git(t, work, "add", "leesmij.txt")
	git(t, work, "commit", "-m", "leesmij")
	git(t, work, "remote", "add", "origin", bare)
	git(t, work, "push", "origin", "master")
	sha := revHEAD(t, work)

	raw := uploadPackRequest(sha)
	var compressed bytes.Buffer
	zw := gzip.NewWriter(&compressed)
	if _, err := zw.Write(raw); err != nil {
		t.Fatal(err)
	}
	if err := zw.Close(); err != nil {
		t.Fatal(err)
	}
	req, err := http.NewRequest(http.MethodPost, ts.URL+"/tim/pakket.git/git-upload-pack", bytes.NewReader(compressed.Bytes()))
	if err != nil {
		t.Fatal(err)
	}
	req.Header.Set("Content-Type", "application/x-git-upload-pack-request")
	req.Header.Set("Accept", "application/x-git-upload-pack-result")
	req.Header.Set("Content-Encoding", "gzip")
	res, err = http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	body, err := io.ReadAll(res.Body)
	res.Body.Close()
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusOK || len(body) == 0 || (!bytes.Contains(body, []byte("NAK")) && !bytes.Contains(body, []byte("PACK"))) {
		t.Fatalf("gzip-POST: status %d, %d bytes, begin %q", res.StatusCode, len(body), body[:min(80, len(body))])
	}

	blob := make([]byte, 4096)
	if _, err := rand.Read(blob); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(work, "groot.bin"), blob, 0o644); err != nil {
		t.Fatal(err)
	}
	git(t, work, "add", "groot.bin")
	git(t, work, "commit", "-m", "groot bestand")
	remote := ts.URL + "/tim/pakket.git"
	git(t, work, "remote", "set-url", "origin", remote)
	auth := "Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte("git:"+token))
	// git push over protocol v1 zet zelf geen Content-Encoding. De aanroep
	// laat http.postBuffer op de standaard staan: een grote body mag niet
	// blijven hangen.
	gitTrace(t, work, auth, "push", "origin", "master")

	for i := 0; i < 40; i++ {
		git(t, work, "branch", fmt.Sprintf("tak-%02d", i))
	}
	gitTrace(t, work, auth, "push", "origin", "--all")

	// Clone vraagt elke branch. Dat verzoek is groter dan 1024 bytes, dus
	// git stuurt Content-Encoding: gzip. Zonder uitpakken is de clone leeg.
	clone := t.TempDir()
	fetchTrace := gitTrace(t, clone, auth, "clone", remote, "kopie")
	if !strings.Contains(fetchTrace, "Content-Encoding: gzip") {
		t.Fatalf("git fetch/clone stuurde geen gzip:\n%s", redactTrace(fetchTrace))
	}
	if _, err := os.Stat(filepath.Join(clone, "kopie", "groot.bin")); err != nil {
		t.Fatal(err)
	}
}

func uploadPackRequest(sha string) []byte {
	want := fmt.Sprintf("want %s multi_ack_detailed no-done side-band-64k ofs-delta\n", sha)
	done := "done\n"
	pkt := func(s string) []byte {
		return []byte(fmt.Sprintf("%04x%s", len(s)+4, s))
	}
	var raw []byte
	raw = append(raw, pkt(want)...)
	raw = append(raw, []byte("0000")...)
	raw = append(raw, pkt(done)...)
	return raw
}

func gitTrace(t *testing.T, dir, auth string, args ...string) string {
	t.Helper()
	if why := gitHTTPGap(); why != "" {
		t.Skip(why)
	}
	cmd := exec.Command("git", append([]string{"-c", "http.extraHeader=" + auth}, args...)...)
	cmd.Dir = dir
	cmd.Env = append(os.Environ(), "GIT_CURL_VERBOSE=1", "GIT_TERMINAL_PROMPT=0")
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, redactTrace(string(out)))
	}
	return string(out)
}

func redactTrace(s string) string {
	var b strings.Builder
	for _, line := range strings.Split(s, "\n") {
		if strings.Contains(line, "Authorization:") || strings.Contains(line, "bg_") {
			continue
		}
		b.WriteString(line)
		b.WriteByte('\n')
	}
	return b.String()
}
