package server

import (
	"context"
	"encoding/json"
	"io"
	"net/http"
	"net/http/cookiejar"
	"net/url"
	"strings"
	"testing"
	"time"

	"gitlab.com/Timfa/bluegit/internal/runnercfg"
	"gitlab.com/Timfa/bluegit/internal/store"
)

func sessionClient(t *testing.T, st *store.Store, base string, uid int64) (*http.Client, string) {
	t.Helper()
	sess, err := st.CreateSession(context.Background(), uid, "dev", time.Now().Add(time.Hour))
	if err != nil {
		t.Fatal(err)
	}
	jar, _ := cookiejar.New(nil)
	u, _ := url.Parse(base)
	jar.SetCookies(u, []*http.Cookie{{Name: "bluegit_session", Value: sess.ID, Path: "/"}})
	c := &http.Client{Jar: jar, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
	return c, sess.CSRF
}

func body(t *testing.T, res *http.Response) string {
	t.Helper()
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	return string(b)
}

func TestAdminRunnerOnlyForInstanceAdmin(t *testing.T) {
	e := newCIEnv(t)
	ctx := context.Background()
	st, base := e.st, e.ts.URL
	tim, _ := st.UserByID(ctx, e.user.ID)
	if !tim.InstanceAdmin {
		t.Skip("eerste gebruiker is geen beheerder in deze opzet")
	}
	bob, _ := st.UpsertUser(ctx, 2, "bob", "", false)
	if err := e.srv.ApplyRunnerSettings(); err != nil {
		t.Fatal(err)
	}

	// Niet-beheerder: UI 403, API 403, ook met scope api.
	bc, bcsrf := sessionClient(t, st, base, bob.ID)
	res, _ := bc.Get(base + "/admin/runner")
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("bob ziet /admin/runner: %d", res.StatusCode)
	}
	res.Body.Close()
	res, _ = bc.PostForm(base+"/admin/runner/pause", url.Values{"csrf": {bcsrf}})
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("bob kan pauzeren: %d", res.StatusCode)
	}
	res.Body.Close()
	bobTok := issue(t, st, bob.ID, "api")
	for _, c := range []struct{ m, p string }{{"GET", "/admin/runner/status"}, {"GET", "/admin/runner/settings"}, {"PUT", "/admin/runner/settings"}, {"POST", "/admin/runner/pause"}, {"GET", "/admin/runner/jobs"}} {
		if code, _ := rapi(t, base, bobTok, c.m, c.p, map[string]any{"concurrency": 3}); code != http.StatusForbidden {
			t.Fatalf("bob %s %s: %d", c.m, c.p, code)
		}
	}
	if code, _ := rapi(t, base, "", "GET", "/admin/runner/status", nil); code != http.StatusUnauthorized {
		t.Fatalf("anoniem: %d", code)
	}
	if e.srv.Runner.Paused() {
		t.Fatal("pauze door niet-beheerder")
	}

	// Beheerder: UI, CSRF verplicht, pauze, instellingen, API.
	tc, tcsrf := sessionClient(t, st, base, tim.ID)
	res, _ = tc.Get(base + "/admin/runner")
	page := body(t, res)
	if res.StatusCode != 200 || !strings.Contains(page, `class="rui"`) || !strings.Contains(page, "Image presets") || !strings.Contains(page, "bluegit/node") {
		t.Fatalf("adminpagina %d: %.300s", res.StatusCode, page)
	}
	res, _ = tc.PostForm(base+"/admin/runner/pause", url.Values{"csrf": {"fout"}})
	if res.StatusCode != http.StatusForbidden {
		t.Fatalf("zonder csrf: %d", res.StatusCode)
	}
	res.Body.Close()
	res, _ = tc.PostForm(base+"/admin/runner/pause", url.Values{"csrf": {tcsrf}})
	if res.StatusCode != http.StatusSeeOther || !e.srv.Runner.Paused() {
		t.Fatalf("pauze: %d %v", res.StatusCode, e.srv.Runner.Paused())
	}
	res.Body.Close()
	form := url.Values{"csrf": {tcsrf}, "name": {"Steve 2"}, "concurrency": {"3"}, "max_images": {"7"}, "cpus": {"1.5"}, "memory_mb": {"2048"}, "pull_policy": {"always"}, "cleanup_work": {"on"}}
	res, _ = tc.PostForm(base+"/admin/runner/settings", form)
	if loc := res.Header.Get("Location"); !strings.Contains(loc, "ok=rui.ok.saved") {
		t.Fatalf("opslaan: %s", loc)
	}
	res.Body.Close()
	if e.srv.Runner.BuiltinName() != "Steve 2" {
		t.Fatalf("naam niet live: %s", e.srv.Runner.BuiltinName())
	}
	res, _ = tc.PostForm(base+"/admin/runner/presets", url.Values{"csrf": {tcsrf}, "name": {"team/tools"}, "image": {"alpine:3.20"}})
	res.Body.Close()
	adminTok := issue(t, st, tim.ID, "runners")
	code, b := rapi(t, base, adminTok, "GET", "/admin/runner/settings", nil)
	var s runnercfg.Settings
	_ = json.Unmarshal(b, &s)
	if code != 200 || s.Concurrency != 3 || s.MaxImages != 7 || !s.Paused || len(s.Presets) != 1 || s.Presets[0].Name != "team/tools" {
		t.Fatalf("api settings %d %s", code, b)
	}
	code, b = rapi(t, base, adminTok, "PUT", "/admin/runner/settings", map[string]any{"concurrency": 0})
	if code != http.StatusUnprocessableEntity {
		t.Fatalf("ongeldig: %d %s", code, b)
	}
	code, b = rapi(t, base, adminTok, "POST", "/admin/runner/resume", nil)
	if code != 200 || e.srv.Runner.Paused() {
		t.Fatalf("hervatten %d %s", code, b)
	}
	code, b = rapi(t, base, adminTok, "GET", "/admin/runner/status", nil)
	if code != 200 || !strings.Contains(string(b), `"safe_to_upgrade":true`) || !strings.Contains(string(b), `"kind":"builtin"`) {
		t.Fatalf("status %d %s", code, b)
	}
}

// Een gepauzeerde ingebouwde runner start geen jobs; na hervatten wel.
// Queued jobs tellen niet als running, dus een self-update wacht er niet op.
func TestBuiltinPauseDrain(t *testing.T) {
	e := newCIEnv(t)
	ctx := context.Background()
	if err := e.srv.ApplyRunnerSettings(); err != nil {
		t.Fatal(err)
	}
	e.rn.Jobs.SetPaused(true)
	pid := e.pipeline()
	for i := 0; i < 3; i++ {
		e.rn.Tick(ctx)
	}
	jobs, _ := e.st.JobsByPipeline(ctx, pid)
	for _, j := range jobs {
		if j.Status == "running" || j.Status == "success" {
			t.Fatalf("job %s liep tijdens pauze: %s", j.Name, j.Status)
		}
	}
	if n, _ := e.st.CountRunningJobs(ctx); n != 0 {
		t.Fatalf("running %d tijdens pauze", n)
	}
	e.rn.Jobs.SetPaused(false)
	p := e.wait(pid, 30*time.Second)
	if p.Status != "success" {
		t.Fatalf("na hervatten: %s", p.Status)
	}
	if got := e.rn.Jobs.Recent(); len(got) != 2 {
		t.Fatalf("recente jobs: %d", len(got))
	}
}

func TestHelpPages(t *testing.T) {
	e := newCIEnv(t)
	for _, p := range []string{"/help", "/help/runners", "/help/agents", "/help/ci"} {
		res, err := http.Get(e.ts.URL + p)
		if err != nil {
			t.Fatal(err)
		}
		page := body(t, res)
		if res.StatusCode != 200 || !strings.Contains(page, "<main") {
			t.Fatalf("%s: %d", p, res.StatusCode)
		}
		if strings.Contains(page, `class="foot"`) || strings.Contains(page, "<footer") {
			t.Fatalf("%s: footer had verwijderd moeten zijn", p)
		}
		if p == "/help/runners" && (!strings.Contains(page, "443") || !strings.Contains(page, `href="/help/agents`)) {
			t.Fatalf("runnerdocs onvolledig of link niet omgezet")
		}
	}
	if res, _ := http.Get(e.ts.URL + "/help/bestaat-niet"); res.StatusCode != 404 {
		t.Fatalf("onbekende help: %d", res.StatusCode)
	}
}

// Heartbeat: lokale pauze (draining) en naam gaan naar de server; een
// runner die draint krijgt geen jobs in de volgorde.
func TestHeartbeatDrainingAndName(t *testing.T) {
	e := newCIEnv(t)
	ctx := context.Background()
	tok, _ := e.st.CreateRunnerRegToken(ctx, "user", e.user.ID, e.user.ID)
	rn, plain, err := e.st.RegisterRunner(ctx, tok, "old-name", "test")
	if err != nil {
		t.Fatal(err)
	}
	req, _ := http.NewRequest("POST", e.ts.URL+"/api/v1/runner/heartbeat", strings.NewReader(`{"draining":true,"name":"nieuwe-naam"}`))
	req.Header.Set("Authorization", "Bearer "+plain)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	b := body(t, res)
	if res.StatusCode != 200 || !strings.Contains(b, "nieuwe-naam") {
		t.Fatalf("heartbeat %d %s", res.StatusCode, b)
	}
	got, _ := e.st.RunnerByID(ctx, rn.ID)
	if !got.Draining || got.Name != "nieuwe-naam" {
		t.Fatalf("niet opgeslagen: %+v", got)
	}
	tim := issue(t, e.st, e.user.ID, "runners")
	code, lb := rapi(t, e.ts.URL, tim, "GET", "/user/runners", nil)
	if code != 200 || !strings.Contains(string(lb), `"status":"draining"`) {
		t.Fatalf("lijst %d %s", code, lb)
	}
}
