package server

import (
	"bytes"
	"context"
	"fmt"
	"net/http"
	"net/http/cookiejar"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

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

func newUpdateServer(t *testing.T) (*Server, *httptest.Server, string) {
	t.Helper()
	dir := t.TempDir()
	st, err := store.Open(filepath.Join(dir, "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: dir,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
		CI:   config.CI{Enabled: false},
	}
	srv := &Server{
		Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true,
		Git: "git", StateDir: dir,
	}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	return srv, ts, dir
}

func TestSelfUpdateDisabledWithoutToken(t *testing.T) {
	t.Setenv(update.TokenEnv, "")
	_, ts, _ := newUpdateServer(t)
	res, err := http.Post(ts.URL+"/api/v1/admin/self-update", "application/json", strings.NewReader(`{"ref":"master"}`))
	if err != nil {
		t.Fatal(err)
	}
	body := read(t, res)
	if res.StatusCode != http.StatusNotFound {
		t.Fatalf("uit hoort 404, kreeg %d %s", res.StatusCode, body)
	}
	res, err = http.Get(ts.URL + "/api/v1/admin/self-update")
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusNotFound {
		t.Fatalf("status uit hoort 404, kreeg %d", res.StatusCode)
	}
	_ = read(t, res)
}

func TestSelfUpdateAuthAndStart(t *testing.T) {
	t.Setenv(update.TokenEnv, "sleutel-voor-de-test")
	srv, ts, dir := newUpdateServer(t)
	var started string
	srv.UpdateStarter = func(_ context.Context, ref string) error {
		started = ref
		return nil
	}
	post := func(token, body string) *http.Response {
		t.Helper()
		req, err := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/admin/self-update", strings.NewReader(body))
		if err != nil {
			t.Fatal(err)
		}
		if token != "" {
			req.Header.Set("Authorization", "Bearer "+token)
		}
		res, err := http.DefaultClient.Do(req)
		if err != nil {
			t.Fatal(err)
		}
		return res
	}

	res := post("fout", `{"ref":"master"}`)
	if res.StatusCode != http.StatusUnauthorized {
		t.Fatalf("foute sleutel %d %s", res.StatusCode, read(t, res))
	}
	_ = read(t, res)

	res = post("sleutel-voor-de-test", `{"ref":"../etc"}`)
	if res.StatusCode != http.StatusBadRequest {
		t.Fatalf("slechte ref %d %s", res.StatusCode, read(t, res))
	}
	_ = read(t, res)
	if started != "" {
		t.Fatal("ongeldige ref startte de unit")
	}

	sha := "0123456789abcdef0123456789abcdef01234567"
	res = post("sleutel-voor-de-test", `{"sha":"`+sha+`"}`)
	body := read(t, res)
	if res.StatusCode != http.StatusAccepted || !strings.Contains(body, `"accepted"`) {
		t.Fatalf("start %d %s", res.StatusCode, body)
	}
	if started != sha {
		t.Fatalf("unit kreeg %q", started)
	}
	raw, err := os.ReadFile(filepath.Join(dir, update.RequestFile))
	if err != nil || string(raw) != sha+"\n" {
		t.Fatalf("verzoek %q %v", raw, err)
	}

	req, err := http.NewRequest(http.MethodGet, ts.URL+"/api/v1/admin/self-update", nil)
	if err != nil {
		t.Fatal(err)
	}
	req.Header.Set("Authorization", "Bearer sleutel-voor-de-test")
	res, err = http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if res.StatusCode != 200 || !strings.Contains(body, `"running":0`) || !strings.Contains(body, `"log":""`) {
		t.Fatalf("status %d %s", res.StatusCode, body)
	}

	var logb strings.Builder
	for i := 1; i <= update.LogTailLines+5; i++ {
		fmt.Fprintf(&logb, "regel %d\n", i)
	}
	if err := os.WriteFile(filepath.Join(dir, update.LogFile), []byte(logb.String()), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := update.WriteStatus(dir, update.Status{Time: "2026-10-22T12:00:00Z", SHA: sha, Result: "failed", Error: "exit 1"}); err != nil {
		t.Fatal(err)
	}
	req, err = http.NewRequest(http.MethodGet, ts.URL+"/api/v1/admin/self-update", nil)
	if err != nil {
		t.Fatal(err)
	}
	req.Header.Set("Authorization", "Bearer sleutel-voor-de-test")
	res, err = http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	body = read(t, res)
	if res.StatusCode != 200 || !strings.Contains(body, `"running":0`) || !strings.Contains(body, `"started_at":"2026-10-22T12:00:00Z"`) || !strings.Contains(body, `"sha":"`+sha+`"`) || !strings.Contains(body, `"result":"failed"`) || !strings.Contains(body, `"status":"failed"`) || !strings.Contains(body, `"error":"exit 1"`) {
		t.Fatalf("logstatus %d %s", res.StatusCode, body)
	}
	if !strings.Contains(body, "regel 6\\nregel 7") || strings.Contains(body, "regel 5\\n") {
		t.Fatalf("logstaart hoort bij regel 6 te beginnen:\n%s", body)
	}

	if err := update.WriteStatus(dir, update.Status{Time: time.Now().UTC().Format(time.RFC3339), SHA: sha, Result: "running"}); err != nil {
		t.Fatal(err)
	}
	started = ""
	res = post("sleutel-voor-de-test", "")
	if res.StatusCode != http.StatusConflict {
		t.Fatalf("bezig %d %s", res.StatusCode, read(t, res))
	}
	_ = read(t, res)
	if started != "" {
		t.Fatal("een lopende update startte opnieuw")
	}
}

func TestSelfUpdateRateLimit(t *testing.T) {
	t.Setenv(update.TokenEnv, "sleutel-voor-de-test")
	_, ts, _ := newUpdateServer(t)
	var last int
	for i := 0; i < updateLimit+1; i++ {
		req, err := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/admin/self-update", bytes.NewReader(nil))
		if err != nil {
			t.Fatal(err)
		}
		req.Header.Set("Authorization", "Bearer fout")
		res, err := http.DefaultClient.Do(req)
		if err != nil {
			t.Fatal(err)
		}
		last = res.StatusCode
		_ = read(t, res)
	}
	if last != http.StatusTooManyRequests {
		t.Fatalf("rate limit %d", last)
	}
}

func TestUpdateStatusOnAdminPages(t *testing.T) {
	dirSetup := func(t *testing.T) (*httptest.Server, string) {
		t.Helper()
		_, ts, dir := newUpdateServer(t)
		sha := "abcdef1234567890abcdef1234567890abcdef12"
		if err := update.WriteStatus(dir, update.Status{Time: "2026-10-22T12:00:00Z", SHA: sha, Result: "ok"}); err != nil {
			t.Fatal(err)
		}
		return ts, sha
	}
	ts, sha := dirSetup(t)
	anon, err := http.Get(ts.URL + "/-/info")
	if err != nil {
		t.Fatal(err)
	}
	anonBody := read(t, anon)
	if strings.Contains(anonBody, sha) || strings.Contains(anonBody, "data-update") {
		t.Fatal("anonieme infopagina toont de update")
	}

	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	_ = read(t, res)
	for _, path := range []string{"/-/info", "/setup"} {
		res, err = client.Get(ts.URL + path)
		if err != nil {
			t.Fatal(err)
		}
		body := read(t, res)
		if res.StatusCode != 200 || !strings.Contains(body, "data-update") || !strings.Contains(body, sha) || !strings.Contains(body, "succeeded") {
			t.Fatalf("%s mist de update (%d):\n%s", path, res.StatusCode, body)
		}
	}
}
