package server

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"testing"
	"time"

	"gitlab.com/Timfa/bluegit/internal/backupserver/config"
	"gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
)

// uiClient is een browser met een cookie.
type uiClient struct {
	t      *testing.T
	h      http.Handler
	cookie *http.Cookie
}

func (c *uiClient) do(method, p string, form url.Values) *httptest.ResponseRecorder {
	var body *strings.Reader
	if form != nil {
		body = strings.NewReader(form.Encode())
	} else {
		body = strings.NewReader("")
	}
	r := httptest.NewRequest(method, p, body)
	if form != nil {
		r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	}
	if c.cookie != nil {
		r.AddCookie(c.cookie)
	}
	w := httptest.NewRecorder()
	c.h.ServeHTTP(w, r)
	for _, ck := range w.Result().Cookies() {
		if ck.Name == sessionCookie {
			c.cookie = ck
		}
	}
	return w
}

var csrfRE = regexp.MustCompile(`name="csrf" value="([0-9a-f]+)"`)

func login(t *testing.T, s *Server) (*uiClient, string) {
	c := &uiClient{t: t, h: s.Handler()}
	if w := c.do("GET", "/", nil); w.Code != 303 || w.Header().Get("Location") != "/login" {
		t.Fatalf("zonder sessie: %d %s", w.Code, w.Header().Get("Location"))
	}
	if w := c.do("POST", "/login", url.Values{"token": {"fout"}}); w.Header().Get("Location") != "/login?fout=1" {
		t.Fatalf("fout token: %s", w.Header().Get("Location"))
	}
	if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 303 || c.cookie == nil {
		t.Fatalf("login %d", w.Code)
	}
	if !c.cookie.HttpOnly || c.cookie.SameSite != http.SameSiteStrictMode {
		t.Fatalf("cookie %+v", c.cookie)
	}
	w := c.do("GET", "/", nil)
	if w.Code != 200 {
		t.Fatalf("index %d", w.Code)
	}
	m := csrfRE.FindStringSubmatch(w.Body.String())
	if m == nil {
		t.Fatal("geen csrf")
	}
	return c, m[1]
}

// Elke wijzigende actie heeft een formulier in de webinterface, elke
// beheerroute zit in Actions, en elk formulier hoort bij een actie.
func TestUIAndAPIParity(t *testing.T) {
	f := newFake(t)
	s := newTestServer(t)
	if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
		t.Fatal(w.Body)
	}
	if _, err := s.SyncNow(t.Context()); err != nil {
		t.Fatal(err)
	}
	if _, err := s.ArchiveNow(); err != nil {
		t.Fatal(err)
	}
	c, _ := login(t, s)
	page := c.do("GET", "/", nil).Body.String()
	// Het koppelformulier staat in een uitklapper zodra er gekoppeld is; het
	// moet er nog steeds zijn.
	forms := map[string]bool{}
	for _, m := range regexp.MustCompile(`action="/ui/act/([a-z.]+)"`).FindAllStringSubmatch(page, -1) {
		forms[m[1]] = true
	}
	for _, a := range s.Actions() {
		switch a.Method {
		case "GET":
			// Getoond op de pagina; download als link.
			if a.Name == "archive.download" && !strings.Contains(page, "/download\">Downloaden") {
				t.Errorf("geen downloadlink")
			}
		default:
			if !forms[a.Name] {
				t.Errorf("actie %s (%s %s) heeft geen formulier in de webinterface", a.Name, a.Method, a.Path)
			}
			delete(forms, a.Name)
		}
	}
	for f := range forms {
		t.Errorf("formulier %s hoort bij geen API-actie", f)
	}
	// Alle GET-acties geven hun gegevens ook op de pagina.
	for _, want := range []string{"Overzicht", "cfg-archive_interval", "cfg-listen", "bluegit-", "/api/v1/admin/config"} {
		if !strings.Contains(page, want) {
			t.Errorf("pagina mist %q", want)
		}
	}
	// De API geeft dezelfde actielijst.
	w := adminReq(s, "GET", "/api/v1/admin/actions", "")
	var al struct {
		Actions []Action `json:"actions"`
	}
	_ = json.Unmarshal(w.Body.Bytes(), &al)
	if len(al.Actions) != len(s.Actions()) {
		t.Fatalf("actions %d", len(al.Actions))
	}
}

func TestUISettingsAndCSRF(t *testing.T) {
	s := newTestServer(t)
	c, csrf := login(t, s)
	form := url.Values{"csrf": {csrf}, "retention_days": {"9"}, "archive_interval": {"12h"}, "rate_limit_kib": {"300"}, "listen": {"127.0.0.1:9999"}}
	if w := c.do("POST", "/ui/act/config.update", form); w.Code != 303 {
		t.Fatalf("opslaan %d %s", w.Code, w.Body)
	}
	page := c.do("GET", "/", nil).Body.String()
	if !strings.Contains(page, "Instellingen opgeslagen") || !strings.Contains(page, "herstart") {
		t.Fatalf("melding ontbreekt")
	}
	cv := s.ConfigView()
	get := func(k string) string {
		for _, f := range cv.Fields {
			if f.Key == k {
				return f.Value
			}
		}
		return ""
	}
	if get("retention_days") != "9" || get("archive_interval") != "12h" || get("listen") != "127.0.0.1:9999" || !cv.Restart {
		t.Fatalf("%+v", cv)
	}
	if s.limiter.Rate() != 300<<10 {
		t.Fatalf("rate %d", s.limiter.Rate())
	}
	if s.cfg().Listen == "127.0.0.1:9999" {
		t.Fatal("listen hoort pas na herstart te gelden")
	}
	// Bewaard: een nieuwe server leest het.
	s2, err := New(s.Cfg, nil)
	if err != nil {
		t.Fatal(err)
	}
	if s2.cfg().RetentionDays != 9 || s2.cfg().Listen != "127.0.0.1:9999" {
		t.Fatalf("na herstart %+v", s2.cfg())
	}
	// Zonder of met fout CSRF-token: geweigerd.
	if w := c.do("POST", "/ui/act/config.update", url.Values{"retention_days": {"1"}}); w.Code != 403 {
		t.Fatalf("zonder csrf %d", w.Code)
	}
	// Ongeldige waarde: foutmelding, niets veranderd.
	c.do("POST", "/ui/act/config.update", url.Values{"csrf": {csrf}, "retention_days": {"-1"}})
	if !strings.Contains(c.do("GET", "/", nil).Body.String(), "mislukt") || s.cfg().RetentionDays != 9 {
		t.Fatal("ongeldige waarde")
	}
	// API met sessiecookie vraagt X-CSRF-Token.
	r := httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`))
	r.AddCookie(c.cookie)
	w := httptest.NewRecorder()
	s.Handler().ServeHTTP(w, r)
	if w.Code != 403 {
		t.Fatalf("cookie zonder csrf-header %d", w.Code)
	}
	r = httptest.NewRequest("PUT", "/api/v1/admin/config", strings.NewReader(`{"retention_days":3}`))
	r.AddCookie(c.cookie)
	r.Header.Set("X-CSRF-Token", csrf)
	w = httptest.NewRecorder()
	s.Handler().ServeHTTP(w, r)
	if w.Code != 200 || s.cfg().RetentionDays != 3 {
		t.Fatalf("cookie met csrf-header %d %s", w.Code, w.Body)
	}
	// Uitloggen.
	c.do("POST", "/logout", url.Values{"csrf": {csrf}})
	if w := c.do("GET", "/", nil); w.Code != 303 {
		t.Fatalf("na uitloggen %d", w.Code)
	}
	// Webinterface mag niet in een iframe van een ander.
	if h := c.do("GET", "/login", nil).Header(); h.Get("X-Frame-Options") != "DENY" {
		t.Fatal("frame")
	}
}

func TestLoginRateLimit(t *testing.T) {
	s := newTestServer(t)
	c := &uiClient{t: t, h: s.Handler()}
	for i := 0; i < 5; i++ {
		c.do("POST", "/login", url.Values{"token": {"fout"}})
	}
	if w := c.do("POST", "/login", url.Values{"token": {s.AdminToken()}}); w.Code != 429 {
		t.Fatalf("na 5 fouten %d", w.Code)
	}
}

func TestAPIConfig(t *testing.T) {
	s := newTestServer(t)
	w := adminReq(s, "PUT", "/api/v1/admin/config", `{"min_free_mb":2048,"full_sync_interval":"30m"}`)
	if w.Code != 200 {
		t.Fatalf("%d %s", w.Code, w.Body)
	}
	if s.cfg().MinFreeMB != 2048 || s.cfg().FullSyncInterval.Duration != 30*time.Minute {
		t.Fatalf("%+v", s.cfg())
	}
	if _, err := os.Stat(filepath.Join(s.Cfg.DataDir, config.SettingsFile)); err != nil {
		t.Fatal(err)
	}
	for _, body := range []string{`{"data_dir":"/tmp"}`, `{"onbekend":1}`, `{"archive_interval":"0s"}`, `{}`, `[1]`} {
		if w := adminReq(s, "PUT", "/api/v1/admin/config", body); w.Code != 400 {
			t.Errorf("%s: %d", body, w.Code)
		}
	}
	w = adminReq(s, "GET", "/api/v1/admin/config", "")
	var cv ConfigView
	_ = json.Unmarshal(w.Body.Bytes(), &cv)
	if len(cv.Fields) != len(config.Fields) {
		t.Fatalf("%s", w.Body)
	}
}

func TestSignedAdminActions(t *testing.T) {
	f := newFake(t)
	s := newTestServer(t)
	if w := adminReq(s, "POST", "/api/v1/admin/connect", `{"url":"`+f.ts.URL+`","key":"bgbk_test"}`); w.Code != 200 {
		t.Fatal(w.Body)
	}
	good := protocol.SigningSecret("bgbk_test")
	call := func(method, p, body string) *httptest.ResponseRecorder {
		r := httptest.NewRequest(method, p, bytes.NewReader([]byte(body)))
		protocol.Sign(r, good, "inst-1", []byte(body), time.Now())
		w := httptest.NewRecorder()
		s.Handler().ServeHTTP(w, r)
		return w
	}
	if w := call("PUT", "/api/v1/admin/config", `{"retention_days":"4"}`); w.Code != 200 || s.cfg().RetentionDays != 4 {
		t.Fatalf("config via BlueGit %d %s", w.Code, w.Body)
	}
	if w := call("GET", "/api/v1/admin/config", ""); w.Code != 200 {
		t.Fatalf("config lezen %d", w.Code)
	}
	if w := call("POST", "/api/v1/admin/connect", `{}`); w.Code != 403 {
		t.Fatalf("connect via BlueGit %d", w.Code)
	}
	if w := call("POST", "/api/v1/admin/rollback", `{"archive":"bluegit-20261115-120000.tar.gz"}`); w.Code != 400 {
		t.Fatalf("rollback zonder confirm %d", w.Code)
	}
	// Handtekening over een ander pad: geweigerd.
	r := httptest.NewRequest("POST", "/api/v1/admin/sync", nil)
	protocol.Sign(r, good, "inst-1", nil, time.Now())
	r.URL.Path = "/api/v1/admin/disconnect"
	w := httptest.NewRecorder()
	s.Handler().ServeHTTP(w, r)
	if w.Code != 401 {
		t.Fatalf("ander pad %d", w.Code)
	}
	if w := call("POST", "/api/v1/admin/disconnect", ``); w.Code != 200 || s.getState().Connected() {
		t.Fatalf("disconnect %d", w.Code)
	}
	// Ontkoppeld: BlueGit kan niets meer.
	if w := call("GET", "/api/v1/admin/status", ""); w.Code != 401 {
		t.Fatalf("na ontkoppelen %d", w.Code)
	}
}
