package runnercfg

import (
	"html/template"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"gitlab.com/Timfa/bluegit/internal/i18n"
)

func TestValidate(t *testing.T) {
	s := Defaults()
	if err := s.Validate(); err != nil {
		t.Fatal(err)
	}
	bad := []func(*Settings){
		func(s *Settings) { s.Concurrency = 0 },
		func(s *Settings) { s.Concurrency = 65 },
		func(s *Settings) { s.MaxImages = 0 },
		func(s *Settings) { s.MemoryMB = 10 },
		func(s *Settings) { s.CPUs = -1 },
		func(s *Settings) { s.PullPolicy = "sometimes" },
		func(s *Settings) { s.Labels = []string{"bad label!"} },
		func(s *Settings) { s.Name = "<script>" },
		func(s *Settings) {
			s.Presets = []Preset{{Name: "team/a", Image: "x:1"}, {Name: "team/a", Image: "y:1"}}
		},
		func(s *Settings) { s.Presets = []Preset{{Name: "team/a", Image: "x:1", From: "y"}} },
		func(s *Settings) { s.Presets = []Preset{{Name: "team/a"}} },
		func(s *Settings) { s.Presets = []Preset{{Name: "team/a", From: "debian"}} },
		func(s *Settings) { s.Presets = []Preset{{Name: "team/a", Dockerfile: "RUN true"}} },
		func(s *Settings) { s.Presets = []Preset{{Name: "geenslash", Image: "x:1"}} },
	}
	for i, f := range bad {
		s := Defaults()
		f(&s)
		err := s.Validate()
		e, ok := err.(Error)
		if !ok || !strings.HasPrefix(e.Key, "rui.err.") {
			t.Fatalf("geval %d: %v", i, err)
		}
		if got := i18n.T(i18n.NL, e.Key, e.Args...); got == e.Key {
			t.Fatalf("geval %d: geen vertaling voor %s", i, e.Key)
		}
	}
	ok := Defaults()
	ok.Labels = []string{" gpu", "gpu", "linux"}
	ok.Presets = []Preset{{Name: "bluegit/python", From: "python:3.13-slim"}, {Name: "Team/Tools", Dockerfile: "FROM debian\nRUN true"}}
	if err := ok.Validate(); err != nil {
		t.Fatal(err)
	}
	if len(ok.Labels) != 2 || ok.Presets[1].Name != "team/tools" {
		t.Fatalf("%+v", ok)
	}
}

func TestRecommend(t *testing.T) {
	r := Recommend(Hardware{CPUs: 8, MemoryMB: 16384, DiskFree: 200})
	if r.Concurrency != 3 || r.CPUs != 2 || r.MemoryMB != 5120 || r.MaxImages != 50 {
		t.Fatalf("8/16/200: %+v", r)
	}
	small := Recommend(Hardware{CPUs: 1, MemoryMB: 1024, DiskFree: 5})
	if small.Concurrency != 1 || small.CPUs < 1 || small.MemoryMB < 512 {
		t.Fatalf("klein: %+v", small)
	}
	if err := small.Validate(); err != nil {
		t.Fatal(err)
	}
	big := Recommend(Hardware{CPUs: 64, MemoryMB: 262144, DiskFree: 4000})
	if big.Concurrency != 8 {
		t.Fatalf("groot: %+v", big)
	}
	if h := Detect(t.TempDir()); h.CPUs < 1 {
		t.Fatalf("detect: %+v", h)
	}
}

func TestRunArgsAndOverrides(t *testing.T) {
	s := Defaults()
	s.CPUs, s.MemoryMB, s.PidsLimit = 1.5, 2048, 100
	if got := strings.Join(s.RunArgs(), " "); got != "--cpus 1.5 --memory 2048m --pids-limit 100" {
		t.Fatal(got)
	}
	s.Presets = []Preset{{Name: "team/tools", Dockerfile: "FROM alpine"}, {Name: "team/node", Image: "node:22"}}
	dir := t.TempDir()
	over, err := s.Overrides(dir, nil)
	if err != nil {
		t.Fatal(err)
	}
	b, err := os.ReadFile(over["team/tools"].Dockerfile)
	if err != nil || !strings.Contains(string(b), "FROM alpine") || over["team/node"].Image != "node:22" {
		t.Fatalf("%v %s %+v", err, b, over)
	}
}

func TestTracker(t *testing.T) {
	var tr Tracker
	if !tr.SafeToUpgrade() {
		t.Fatal("leeg is veilig")
	}
	tr.Start(JobInfo{ID: 1, Name: "build", Image: "a"})
	tr.Start(JobInfo{ID: 2, Name: "test", Image: "b"})
	if tr.SafeToUpgrade() || len(tr.Active()) != 2 {
		t.Fatal("actief")
	}
	tr.Finish(1, "success")
	tr.Finish(99, "failed")
	if len(tr.Active()) != 1 || len(tr.Recent()) != 1 || tr.Recent()[0].Status != "success" {
		t.Fatalf("%+v %+v", tr.Active(), tr.Recent())
	}
	tr.Finish(2, "failed")
	time.Sleep(time.Millisecond)
	tr.Start(JobInfo{ID: 3, Image: "c"})
	if st := tr.StaleImages(1); len(st) != 2 {
		t.Fatalf("oud: %v", st)
	}
	tr.SetPaused(true)
	if !tr.Paused() {
		t.Fatal("pauze")
	}
}

func testHandler(t *testing.T, allow bool) (*Handler, *http.ServeMux) {
	dir := t.TempDir()
	h := &Handler{
		File: &File{Path: filepath.Join(dir, "settings.json")}, Default: Defaults(), Tracker: &Tracker{}, WorkDir: dir,
		Status: func() Status { return Status{Kind: "standalone", Name: "pc", Online: true} },
		Lang:   func(r *http.Request) i18n.Lang { return i18n.Parse(r.URL.Query().Get("lang")) },
		Auth: func(w http.ResponseWriter, r *http.Request, write bool) bool {
			if !allow {
				http.Error(w, "no", http.StatusUnauthorized)
			}
			return allow
		},
		CSRF:      func(*http.Request) (string, string) { return "csrf", "goed" },
		CheckCSRF: func(r *http.Request) bool { return r.FormValue("csrf") == "goed" },
		Layout: func(w http.ResponseWriter, r *http.Request, lang i18n.Lang, title string, body template.HTML) {
			_, _ = w.Write([]byte(title + "\n" + string(body)))
		},
	}
	mux := http.NewServeMux()
	h.Mount(mux, true)
	return h, mux
}

func post(mux http.Handler, path string, v url.Values) *httptest.ResponseRecorder {
	req := httptest.NewRequest("POST", path, strings.NewReader(v.Encode()))
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	w := httptest.NewRecorder()
	mux.ServeHTTP(w, req)
	return w
}

func TestHandlerPauseSettingsPresets(t *testing.T) {
	h, mux := testHandler(t, true)
	if w := post(mux, "/pause", url.Values{"csrf": {"fout"}}); w.Code != http.StatusForbidden {
		t.Fatalf("csrf: %d", w.Code)
	}
	if w := post(mux, "/pause", url.Values{"csrf": {"goed"}}); w.Code != http.StatusSeeOther || !h.Tracker.Paused() || !h.Current().Paused {
		t.Fatalf("pauze: %d", w.Code)
	}
	w := post(mux, "/settings", url.Values{"csrf": {"goed"}, "name": {"Mijn PC"}, "concurrency": {"4"}, "max_images": {"9"}, "cpus": {"1,5"}, "labels": {"gpu, linux"}, "pull_policy": {"never"}})
	if !strings.Contains(w.Header().Get("Location"), "ok=rui.ok.saved") {
		t.Fatal(w.Header().Get("Location"))
	}
	s := h.Current()
	if s.Name != "Mijn PC" || s.Concurrency != 4 || s.CPUs != 1.5 || len(s.Labels) != 2 || s.PullPolicy != "never" || !s.Paused {
		t.Fatalf("%+v", s)
	}
	w = post(mux, "/settings", url.Values{"csrf": {"goed"}, "concurrency": {"999"}, "max_images": {"9"}})
	if !strings.Contains(w.Header().Get("Location"), "err=rui.err.concurrency") || h.Current().Concurrency != 4 {
		t.Fatalf("ongeldig: %s", w.Header().Get("Location"))
	}
	post(mux, "/presets", url.Values{"csrf": {"goed"}, "name": {"team/tools"}, "image": {"alpine:3.20"}})
	w = post(mux, "/presets", url.Values{"csrf": {"goed"}, "name": {"team/x"}, "image": {"a"}, "from": {"b"}})
	if !strings.Contains(w.Header().Get("Location"), "rui.err.presetBoth") {
		t.Fatal(w.Header().Get("Location"))
	}
	if len(h.Current().Presets) != 1 {
		t.Fatal("preset")
	}
	post(mux, "/recommend", url.Values{"csrf": {"goed"}})
	if h.Current().PidsLimit != 4096 {
		t.Fatal("aanbeveling")
	}
	post(mux, "/presets/delete", url.Values{"csrf": {"goed"}, "name": {"team/tools"}})
	post(mux, "/resume", url.Values{"csrf": {"goed"}})
	if len(h.Current().Presets) != 0 || h.Tracker.Paused() {
		t.Fatal("verwijderen/hervatten")
	}
	for _, l := range []string{"en", "nl", "de", "fr"} {
		req := httptest.NewRequest("GET", "/?lang="+l+"&err=rui.err.label|x", nil)
		rw := httptest.NewRecorder()
		mux.ServeHTTP(rw, req)
		page := rw.Body.String()
		if rw.Code != 200 || !strings.Contains(page, `class="rui"`) || strings.Contains(page, "rui.") || strings.Contains(page, "rdoc.") {
			t.Fatalf("%s: %d onvertaalde sleutel in pagina", l, rw.Code)
		}
	}
}

func TestHandlerAuth(t *testing.T) {
	h, mux := testHandler(t, false)
	for _, c := range []struct{ m, p string }{{"GET", "/"}, {"GET", "/api/status"}, {"PUT", "/api/settings"}, {"POST", "/api/pause"}, {"GET", "/api/jobs"}} {
		req := httptest.NewRequest(c.m, c.p, strings.NewReader(`{"paused":true}`))
		w := httptest.NewRecorder()
		mux.ServeHTTP(w, req)
		if w.Code != http.StatusUnauthorized {
			t.Fatalf("%s %s: %d", c.m, c.p, w.Code)
		}
	}
	if w := post(mux, "/pause", url.Values{"csrf": {"goed"}}); w.Code != http.StatusUnauthorized || h.Current().Paused {
		t.Fatal("pauze zonder auth")
	}
}

func TestHandlerAPI(t *testing.T) {
	h, mux := testHandler(t, true)
	req := httptest.NewRequest("PUT", "/api/settings", strings.NewReader(`{"concurrency":2,"memory_mb":1024}`))
	w := httptest.NewRecorder()
	mux.ServeHTTP(w, req)
	if w.Code != 200 || h.Current().Concurrency != 2 || h.Current().MaxImages != 20 {
		t.Fatalf("%d %s", w.Code, w.Body)
	}
	req = httptest.NewRequest("PUT", "/api/settings", strings.NewReader(`{"concurrency":0}`))
	w = httptest.NewRecorder()
	mux.ServeHTTP(w, req)
	if w.Code != http.StatusUnprocessableEntity {
		t.Fatal(w.Code)
	}
	h.Tracker.Start(JobInfo{ID: 5, Name: "build"})
	req = httptest.NewRequest("POST", "/api/pause", nil)
	w = httptest.NewRecorder()
	mux.ServeHTTP(w, req)
	if !strings.Contains(w.Body.String(), `"safe_to_upgrade":false`) || !h.Tracker.Paused() {
		t.Fatal(w.Body.String())
	}
	h.Tracker.Finish(5, "success")
	req = httptest.NewRequest("GET", "/api/status", nil)
	w = httptest.NewRecorder()
	mux.ServeHTTP(w, req)
	if !strings.Contains(w.Body.String(), `"safe_to_upgrade":true`) || !strings.Contains(w.Body.String(), `"paused":true`) {
		t.Fatal(w.Body.String())
	}
}

func TestCleanupCache(t *testing.T) {
	dir := t.TempDir()
	for i, n := range []string{"old", "new"} {
		p := filepath.Join(dir, n)
		_ = os.MkdirAll(p, 0o755)
		_ = os.WriteFile(filepath.Join(p, "f"), make([]byte, 1<<20), 0o644)
		_ = os.Chtimes(p, time.Now().Add(time.Duration(i)*time.Hour), time.Now().Add(time.Duration(i)*time.Hour))
	}
	got := pruneDir(dir, 1<<20)
	if len(got) != 1 || !strings.Contains(got[0], "old") {
		t.Fatal(got)
	}
}
