package server

import (
	"archive/tar"
	"archive/zip"
	"bytes"
	"compress/gzip"
	"crypto/sha256"
	"encoding/hex"
	"io"
	"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 TestCommitArchivePublicAndStable(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}
	anon := &http.Client{}

	page := read(t, mustGet(t, tim, ts.URL+"/login"))
	page = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"archief"}, "visibility": {"public"},
	}))
	page = read(t, mustPost(t, tim, ts.URL+"/settings/tokens", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"laptop"},
	}))
	token := between(page, `<p class="code">`, "</p>")
	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\n")
	git(t, work, "add", "hello.txt")
	git(t, work, "commit", "-m", "start")
	remote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/archief.git"
	git(t, work, "remote", "add", "origin", remote)
	git(t, work, "push", "-u", "origin", "master")
	sha := strings.TrimSpace(gitOutOK(t, work, "rev-parse", "HEAD"))

	tarURL := ts.URL + "/tim/archief/-/archive/" + sha + "/archief-" + sha + ".tar.gz"
	first := getBody(t, anon, tarURL)
	second := getBody(t, anon, tarURL)
	if first.code != http.StatusOK || !bytes.Equal(first.body, second.body) {
		t.Fatalf("tar.gz %d, gelijk %v, lengte %d", first.code, bytes.Equal(first.body, second.body), len(first.body))
	}
	if len(first.body) < 2 || first.body[0] != 0x1f || first.body[1] != 0x8b {
		t.Fatal("geen gzip")
	}
	if !strings.Contains(first.header.Get("Content-Disposition"), "archief-"+sha+".tar.gz") {
		t.Fatalf("bestandsnaam: %s", first.header.Get("Content-Disposition"))
	}
	sum := sha256.Sum256(first.body)
	if hex.EncodeToString(sum[:]) != hex.EncodeToString(sha256Sum(second.body)) {
		t.Fatal("sha256 verschilt tussen twee downloads")
	}
	names := tarNames(t, first.body)
	want := "archief-" + sha + "/hello.txt"
	if !containsString(names, want) {
		t.Fatalf("tar mist %s in %v", want, names)
	}

	zipURL := ts.URL + "/tim/archief/-/archive/" + sha + "/archief-" + sha + ".zip"
	zipRes := getBody(t, anon, zipURL)
	if zipRes.code != http.StatusOK || len(zipRes.body) < 2 || zipRes.body[0] != 'P' || zipRes.body[1] != 'K' {
		t.Fatalf("zip %d", zipRes.code)
	}
	zr, err := zip.NewReader(bytes.NewReader(zipRes.body), int64(len(zipRes.body)))
	if err != nil {
		t.Fatal(err)
	}
	found := false
	for _, f := range zr.File {
		if f.Name == want {
			found = true
		}
	}
	if !found {
		t.Fatalf("zip mist %s", want)
	}
	again := getBody(t, anon, zipURL)
	if !bytes.Equal(zipRes.body, again.body) {
		t.Fatal("zip verschilt tussen twee downloads")
	}

	for _, raw := range []string{
		ts.URL + "/tim/archief/-/archive/" + sha[:12] + "/archief.tar.gz",
		ts.URL + "/tim/archief/-/archive/master/archief-master.tar.gz",
		ts.URL + "/tim/archief/-/archive/" + sha + "/archief-" + sha + ".tar.bz2",
		ts.URL + "/tim/archief/-/archive/" + strings.Repeat("ab", 20) + "/archief.tar.gz",
	} {
		res := getBody(t, anon, raw)
		if res.code != http.StatusNotFound {
			t.Fatalf("%s: %d", raw, res.code)
		}
	}

	page = read(t, mustPost(t, tim, ts.URL+"/new/repo", url.Values{
		"csrf": {csrfOf(t, page)}, "name": {"geheim"}, "visibility": {"private"},
	}))
	secret := t.TempDir()
	git(t, secret, "init", "-b", "master")
	git(t, secret, "config", "user.email", "tim@users.git.timfalken.com")
	git(t, secret, "config", "user.name", "tim")
	writeFile(t, filepath.Join(secret, "hello.txt"), "geheim\n")
	git(t, secret, "add", "hello.txt")
	git(t, secret, "commit", "-m", "geheim")
	privRemote := strings.Replace(ts.URL, "http://", "http://tim:"+token+"@", 1) + "/tim/geheim.git"
	git(t, secret, "remote", "add", "origin", privRemote)
	git(t, secret, "push", "-u", "origin", "master")
	privSHA := strings.TrimSpace(gitOutOK(t, secret, "rev-parse", "HEAD"))
	hidden := getBody(t, anon, ts.URL+"/tim/geheim/-/archive/"+privSHA+"/geheim-"+privSHA+".tar.gz")
	if hidden.code != http.StatusNotFound {
		t.Fatalf("privé-archief: %d", hidden.code)
	}
}

type bodyResult struct {
	code   int
	header http.Header
	body   []byte
}

func getBody(t *testing.T, c *http.Client, raw string) bodyResult {
	t.Helper()
	res := mustGet(t, c, raw)
	defer res.Body.Close()
	body, err := io.ReadAll(res.Body)
	if err != nil {
		t.Fatal(err)
	}
	return bodyResult{code: res.StatusCode, header: res.Header, body: body}
}

func tarNames(t *testing.T, gz []byte) []string {
	t.Helper()
	zr, err := gzip.NewReader(bytes.NewReader(gz))
	if err != nil {
		t.Fatal(err)
	}
	defer zr.Close()
	tr := tar.NewReader(zr)
	var names []string
	for {
		hdr, err := tr.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			t.Fatal(err)
		}
		names = append(names, hdr.Name)
	}
	return names
}

func sha256Sum(b []byte) []byte {
	sum := sha256.Sum256(b)
	return sum[:]
}

func containsString(list []string, want string) bool {
	for _, item := range list {
		if item == want {
			return true
		}
	}
	return false
}
