package server

import (
	"bytes"
	"context"
	"encoding/json"
	"io"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
	"time"

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

func rapi(t *testing.T, base, tok, method, path string, body any) (int, []byte) {
	t.Helper()
	var rd io.Reader
	if body != nil {
		b, _ := json.Marshal(body)
		rd = bytes.NewReader(b)
	}
	req, _ := http.NewRequest(method, base+"/api/v1"+path, rd)
	if tok != "" {
		req.Header.Set("Authorization", "Bearer "+tok)
	}
	if body != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	return res.StatusCode, b
}

func issue(t *testing.T, st *store.Store, uid int64, scopes string) string {
	t.Helper()
	tok, _, err := st.IssueToken(context.Background(), uid, store.TokenRequest{Name: "t-" + scopes, Scopes: scopes})
	if err != nil {
		t.Fatal(err)
	}
	return tok
}

func TestRunnerAPIAuthorization(t *testing.T) {
	e := newCIEnv(t)
	ctx := context.Background()
	st, base := e.st, e.ts.URL
	bob, _ := st.UpsertUser(ctx, 2, "bob", "", false)
	carol, _ := st.UpsertUser(ctx, 3, "carol", "", false)
	g, err := st.CreateGroup(ctx, e.user.ID, "Team", "team", "", access.RoleReadonly)
	if err != nil {
		t.Fatal(err)
	}
	_ = st.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper)
	_ = st.SetMember(ctx, "group", g.ID, "carol", access.RoleMaintainer)

	timTok := issue(t, st, e.user.ID, "runners")
	timRead := issue(t, st, e.user.ID, "read_api")
	timRepo := issue(t, st, e.user.ID, "read_repository")
	bobTok := issue(t, st, bob.ID, "api")
	carolTok := issue(t, st, carol.ID, "runners")

	// Account: token maken, lijst, hernoemen, pauzeren, hervatten.
	code, b := rapi(t, base, timTok, "POST", "/user/runners/registration-token", map[string]any{})
	if code != 201 || !strings.Contains(string(b), `"token":"bgrr_`) {
		t.Fatalf("reg token: %d", code)
	}
	var reg struct{ Token string }
	_ = json.Unmarshal(b, &reg)
	rn, _, err := st.RegisterRunner(ctx, reg.Token, "tim-pc", "test")
	if err != nil {
		t.Fatal(err)
	}
	id := "/user/runners/" + itoa(rn.ID)
	if code, b = rapi(t, base, timRead, "GET", "/user/runners", nil); code != 200 || !strings.Contains(string(b), `"tim-pc"`) || !strings.Contains(string(b), `"last_seen"`) {
		t.Fatalf("list: %d %s", code, b)
	}
	if code, _ = rapi(t, base, timRead, "POST", id+"/pause", nil); code != 403 {
		t.Fatalf("read_api may not pause: %d", code)
	}
	if code, _ = rapi(t, base, timRepo, "GET", "/user/runners", nil); code != 403 {
		t.Fatalf("read_repository may not list runners: %d", code)
	}
	if code, b = rapi(t, base, timTok, "PUT", id, map[string]any{"name": "tim-laptop"}); code != 200 || !strings.Contains(string(b), "tim-laptop") {
		t.Fatalf("rename: %d %s", code, b)
	}
	if code, b = rapi(t, base, timTok, "POST", id+"/pause", nil); code != 200 || !strings.Contains(string(b), `"status":"paused"`) {
		t.Fatalf("pause: %d %s", code, b)
	}
	if code, b = rapi(t, base, timTok, "POST", id+"/resume", nil); code != 200 || !strings.Contains(string(b), `"paused":false`) {
		t.Fatalf("resume: %d %s", code, b)
	}
	if code, b = rapi(t, base, timTok, "PUT", "/user/runner-settings", map[string]any{"preference": "own_first"}); code != 200 || !strings.Contains(string(b), "own_first") {
		t.Fatalf("pref: %d %s", code, b)
	}
	if code, b = rapi(t, base, timTok, "GET", id+"/jobs", nil); code != 200 || string(bytes.TrimSpace(b)) != "[]" {
		t.Fatalf("jobs: %d %s", code, b)
	}

	// Cross-account: bob (api-token) ziet of wijzigt tims runner niet.
	for _, c := range []struct{ m, p string }{{"GET", id}, {"PUT", id}, {"POST", id + "/pause"}, {"DELETE", id}, {"GET", id + "/jobs"}} {
		if code, _ = rapi(t, base, bobTok, c.m, c.p, map[string]any{"name": "x"}); code != 404 {
			t.Fatalf("bob %s %s: %d", c.m, c.p, code)
		}
	}
	if code, b = rapi(t, base, bobTok, "GET", "/user/runners", nil); code != 200 || strings.Contains(string(b), "tim-laptop") {
		t.Fatalf("bob list: %d %s", code, b)
	}

	// Groep: carol (maintainer) mag, bob (developer) niet.
	if code, b = rapi(t, base, carolTok, "POST", "/groups/team/runners/registration-token", map[string]any{}); code != 201 {
		t.Fatalf("carol group token: %d %s", code, b)
	}
	_ = json.Unmarshal(b, &reg)
	grn, _, err := st.RegisterRunner(ctx, reg.Token, "grp", "test")
	if err != nil {
		t.Fatal(err)
	}
	gid := "/groups/team/runners/" + itoa(grn.ID)
	for _, c := range []struct{ m, p string }{
		{"GET", "/groups/team/runners"}, {"POST", "/groups/team/runners/registration-token"},
		{"POST", gid + "/pause"}, {"DELETE", gid}, {"PUT", "/groups/team/runner-settings"},
	} {
		if code, _ = rapi(t, base, bobTok, c.m, c.p, map[string]any{"builtin_first": true, "enabled": true}); code != 403 {
			t.Fatalf("bob (developer) %s %s: %d", c.m, c.p, code)
		}
	}
	// Opt-in voor je eigen runners mag elk groepslid (alleen voor jezelf).
	if code, b = rapi(t, base, bobTok, "PUT", "/groups/team/runner-optin", map[string]any{"enabled": true}); code != 200 || !strings.Contains(string(b), "bob") {
		t.Fatalf("bob (developer) optin: %d %s", code, b)
	}
	if code, _ = rapi(t, base, bobTok, "PUT", "/groups/team/runner-optin", map[string]any{"enabled": false}); code != 200 {
		t.Fatalf("bob optout: %d", code)
	}
	// Tims account-runner is niet bereikbaar via het groepspad (en omgekeerd).
	if code, _ = rapi(t, base, carolTok, "GET", "/groups/team/runners/"+itoa(rn.ID), nil); code != 404 {
		t.Fatalf("account runner via group path: %d", code)
	}
	if code, _ = rapi(t, base, timTok, "GET", "/user/runners/"+itoa(grn.ID), nil); code != 404 {
		t.Fatalf("group runner via user path: %d", code)
	}
	if code, b = rapi(t, base, carolTok, "PUT", "/groups/team/runner-settings", map[string]any{"builtin_first": true}); code != 200 || !strings.Contains(string(b), `"builtin_first":true`) {
		t.Fatalf("builtin_first: %d %s", code, b)
	}
	if code, b = rapi(t, base, carolTok, "PUT", "/groups/team/runner-optin", map[string]any{"enabled": true}); code != 200 || !strings.Contains(string(b), `"enabled":true`) || !strings.Contains(string(b), "carol") {
		t.Fatalf("optin: %d %s", code, b)
	}
	// Opt-in geldt alleen voor jezelf: tim ziet zijn eigen (uit), carol staat in de lijst.
	if code, b = rapi(t, base, timTok, "GET", "/groups/team/runner-optin", nil); code != 200 || !strings.Contains(string(b), `"enabled":false`) {
		t.Fatalf("tim optin: %d %s", code, b)
	}
	if code, b = rapi(t, base, timTok, "GET", "/groups/team/runner-settings", nil); !strings.Contains(string(b), `"carol"`) {
		t.Fatalf("opted_in list: %d %s", code, b)
	}
	// Onbekende/privé groep voor een buitenstaander: 404.
	dave, _ := st.UpsertUser(ctx, 4, "dave", "", false)
	daveTok := issue(t, st, dave.ID, "api")
	if code, _ = rapi(t, base, daveTok, "PUT", "/groups/team/runner-optin", map[string]any{"enabled": true}); code != 404 && code != 403 {
		t.Fatalf("dave optin: %d", code)
	}
	if code, _ = rapi(t, base, daveTok, "GET", "/groups/team/runners", nil); code != 404 && code != 403 {
		t.Fatalf("dave: %d", code)
	}

	// Job-token en runner-token: geen toegang tot runnerbeheer.
	pid := e.pipeline()
	jobs, _ := st.JobsByPipeline(ctx, pid)
	jobTok, err := st.CreateJobToken(ctx, jobs[0].ID)
	if err != nil {
		t.Fatal(err)
	}
	reg2, _ := st.CreateRunnerRegToken(ctx, "user", e.user.ID, e.user.ID)
	_, runnerTok, _ := st.RegisterRunner(ctx, reg2, "other", "test")
	for _, tok := range []string{jobTok, runnerTok, ""} {
		for _, c := range []struct{ m, p string }{{"GET", "/user/runners"}, {"POST", "/user/runners/registration-token"}, {"GET", "/groups/team/runners"}, {"PUT", "/user/runner-settings"}} {
			if code, _ = rapi(t, base, tok, c.m, c.p, map[string]any{}); code != 401 {
				t.Fatalf("token %.4s… %s %s: %d", tok, c.m, c.p, code)
			}
		}
	}

	// Verwijderen: daarna weg uit de lijst en het runner-token werkt niet meer.
	if code, _ = rapi(t, base, timTok, "DELETE", id, nil); code != 204 {
		t.Fatalf("delete: %d", code)
	}
	if code, b = rapi(t, base, timTok, "GET", "/user/runners", nil); strings.Contains(string(b), "tim-laptop") {
		t.Fatalf("still listed: %s", b)
	}
}

func itoa(n int64) string { return jsonNum(n) }

func jsonNum(n int64) string { b, _ := json.Marshal(n); return string(b) }

// Volledige agent-setup met alleen een access token: token via de API,
// bluegit-runner register via env, en via de API zien dat hij online komt.
func TestRunnerAgentSetupViaAPI(t *testing.T) {
	e := newCIEnv(t)
	bin := buildRunnerBinary(t)
	tok := issue(t, e.st, e.user.ID, "runners")
	code, b := rapi(t, e.ts.URL, tok, "POST", "/user/runners/registration-token", map[string]any{})
	if code != 201 {
		t.Fatalf("reg token: %d", code)
	}
	var reg struct{ Token string }
	_ = json.Unmarshal(b, &reg)
	cfg := filepath.Join(t.TempDir(), "config.yml")
	_ = os.WriteFile(cfg, []byte("docker: "+e.docker+"\nwork_dir: "+t.TempDir()+"\n"), 0o600)
	cmd := exec.Command(bin, "register", "--config", cfg)
	cmd.Env = append(os.Environ(), "BLUEGIT_RUNNER_URL="+e.ts.URL, "BLUEGIT_RUNNER_REGISTRATION_TOKEN="+reg.Token, "BLUEGIT_RUNNER_NAME=agent-box")
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("register: %v %s", err, out)
	}
	// Direct na registratie: in de lijst. Zet last_seen terug zodat we
	// zien dat "run" hem online maakt.
	ctx, stop := context.WithCancel(context.Background())
	defer stop()
	run := exec.CommandContext(ctx, bin, "run", "--config", cfg)
	if err := run.Start(); err != nil {
		t.Fatal(err)
	}
	defer func() { stop(); _ = run.Wait() }()
	deadline := time.Now().Add(30 * time.Second)
	for time.Now().Before(deadline) {
		_, b = rapi(t, e.ts.URL, tok, "GET", "/user/runners", nil)
		var rs []map[string]any
		_ = json.Unmarshal(b, &rs)
		if len(rs) == 1 && rs[0]["name"] == "agent-box" && rs[0]["status"] == "online" && rs[0]["version"] == "dev" {
			// En hij draait echt een job.
			_ = e.st.SetUserRunnerPref(context.Background(), e.user.ID, store.RunnerPrefOwnFirst)
			pid := e.pipeline()
			p := e.wait(pid, 60*time.Second)
			if p.Status != "success" {
				t.Fatalf("pipeline %s", p.Status)
			}
			_, b = rapi(t, e.ts.URL, tok, "GET", "/user/runners/"+jsonNum(int64(rs[0]["id"].(float64)))+"/jobs", nil)
			if !strings.Contains(string(b), `"project":"tim/app"`) || !strings.Contains(string(b), `"success"`) {
				t.Fatalf("runner jobs: %s", b)
			}
			return
		}
		time.Sleep(300 * time.Millisecond)
	}
	t.Fatalf("runner not online via API: %s", b)
}
