package server

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"image"
	"image/color"
	"image/png"
	"io"
	"net/http"
	"net/http/cookiejar"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"
	"testing"

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

func TestPutProjectDefaultBranch(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	ts, client, srv := graphTestRepo(t)
	tok := apiToken(t, client, ts.URL)
	code, b := rapi(t, ts.URL, tok, "PUT", "/projects/tim/grafiek", map[string]any{"default_branch": "feature"})
	if code != 200 {
		t.Fatalf("PUT %d %s", code, b)
	}
	var out map[string]any
	if err := json.Unmarshal(b, &out); err != nil {
		t.Fatal(err)
	}
	if out["default_branch"] != "feature" {
		t.Fatalf("antwoord: %s", b)
	}
	repo, err := srv.Store.RepoByPath(context.Background(), "tim", "grafiek")
	if err != nil || repo.DefaultBranch != "feature" {
		t.Fatalf("db: %+v %v", repo, err)
	}
	dir := gitrepo.Dir(srv.StoragePath(), "tim", "grafiek")
	head, err := exec.Command("git", "-C", dir, "symbolic-ref", "--short", "HEAD").Output()
	if err != nil || strings.TrimSpace(string(head)) != "feature" {
		t.Fatalf("HEAD %q %v", head, err)
	}
	code, b = rapi(t, ts.URL, tok, "PUT", "/projects/tim/grafiek", map[string]any{"default_branch": "bestaat-niet"})
	if code != 400 {
		t.Fatalf("ontbrekende branch: %d %s", code, b)
	}
}

func TestProjectCIPaused(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	ts, client, srv := graphTestRepo(t)
	srv.Cfg.CI.Enabled = true
	tok := apiToken(t, client, ts.URL)
	code, b := rapi(t, ts.URL, tok, "PUT", "/projects/tim/grafiek", map[string]any{"ci_paused": true})
	if code != 200 || !strings.Contains(string(b), `"ci_paused":true`) {
		t.Fatalf("pause %d %s", code, b)
	}
	repo, _ := srv.Store.RepoByPath(context.Background(), "tim", "grafiek")
	if !repo.CIPaused {
		t.Fatal("db niet gepauzeerd")
	}
	settings := read(t, mustGet(t, client, ts.URL+"/tim/grafiek/-/settings"))
	if !strings.Contains(settings, `name="ci_paused"`) || !strings.Contains(settings, "checked") {
		t.Fatalf("settings-ui mist checkbox:\n%s", settings)
	}
	tim, err := srv.Store.UserByUsername(context.Background(), "tim")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := srv.opRunPipeline(context.Background(), tim, repo, "master", "api"); err == nil {
		t.Fatal("handmatige run had geweigerd moeten worden")
	}
	if got := srv.startPipeline(context.Background(), repo, strings.Repeat("a", 40), "refs/heads/master", "tim", "push", "", nil); got != 0 {
		t.Fatalf("push zou geen pipeline moeten queueen: %d", got)
	}
	code, b = rapi(t, ts.URL, tok, "POST", "/projects/tim/grafiek/pipelines", map[string]any{"ref": "master"})
	if code != 409 {
		t.Fatalf("API start %d %s", code, b)
	}
}

func TestAdminRunnerStatusDockerUnreachable(t *testing.T) {
	dir := t.TempDir()
	bin := filepath.Join(dir, "docker")
	script := "#!/bin/sh\necho 'Cannot connect to the Docker daemon' >&2\nexit 1\n"
	if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {
		t.Fatal(err)
	}
	srv := &Server{
		Cfg:    config.Config{BaseURL: "http://git.example", CI: config.CI{Docker: bin}},
		Runner: &runner.Runner{},
	}
	st := srv.builtinStatus()
	if st.Online {
		t.Fatalf("online zou false moeten zijn: %+v", st)
	}
	if st.Docker.Reachable || st.Docker.Error == "" {
		t.Fatalf("docker status: %+v", st.Docker)
	}
}

func TestRepoLogoICO(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	ts, client, srv := graphTestRepo(t)
	srv.StateDir = t.TempDir()
	page := read(t, mustGet(t, client, ts.URL+"/tim/grafiek/-/settings"))
	body, ctype := multipartLogo(t, csrfOf(t, page), encodeICOFile(solidPNG(16, 16)), "logo.ico")
	req, err := http.NewRequest(http.MethodPost, ts.URL+"/tim/grafiek/-/logo", body)
	if err != nil {
		t.Fatal(err)
	}
	req.Header.Set("Content-Type", ctype)
	res, err := client.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	_ = read(t, res)
	repo, err := srv.Store.RepoByPath(context.Background(), "tim", "grafiek")
	if err != nil || repo.LogoMIME != "image/x-icon" {
		t.Fatalf("mime %q %v", repo.LogoMIME, err)
	}
	res, err = client.Get(ts.URL + "/tim/grafiek/-/logo")
	if err != nil {
		t.Fatal(err)
	}
	defer res.Body.Close()
	if res.StatusCode != 200 || res.Header.Get("Content-Type") != "image/x-icon" {
		t.Fatalf("serve %d %s", res.StatusCode, res.Header.Get("Content-Type"))
	}
}

func TestJobHeaderUserchipWithoutAvatar(t *testing.T) {
	css, err := os.ReadFile("static/style.css")
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(css), ".userchip, a.userchip-link") || !strings.Contains(string(css), "inline-flex") {
		t.Fatal("userchip-css ontbreekt")
	}
	storage := t.TempDir()
	st, err := store.Open(filepath.Join(storage, "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: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git"}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	_ = read(t, mustGet(t, client, ts.URL+"/login"))
	ctx := context.Background()
	user, err := st.UserByUsername(ctx, "tim")
	if err != nil {
		t.Fatal(err)
	}
	if user.AvatarURL != "" {
		t.Fatal("verwacht geen avatar")
	}
	repo, err := st.CreateRepo(ctx, "user", user.ID, "demo", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	pid, err := st.CreatePipeline(ctx, repo.ID, strings.Repeat("a", 40), "refs/heads/master", "push", "tim", "run", []store.NewJob{
		{Name: "build", Stage: "test", Script: "true"},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, _ := st.JobsByPipeline(ctx, pid)
	if err := st.FinishJob(ctx, jobs[0].ID, "success", ""); err != nil {
		t.Fatal(err)
	}
	page := read(t, mustGet(t, client, ts.URL+"/tim/demo/-/pipelines/"+strconv.FormatInt(pid, 10)+"/jobs/"+strconv.FormatInt(jobs[0].ID, 10)))
	if !strings.Contains(page, `class="userchip"`) || !strings.Contains(page, `class="userchip-name"`) {
		t.Fatalf("userchip ontbreekt:\n%s", page)
	}
	if !strings.Contains(page, ">tim<") {
		t.Fatalf("naam ontbreekt:\n%s", page)
	}
	if strings.Contains(page, `class="avatarlink"`) {
		t.Fatalf("naam mag niet in avatarlink:\n%s", page)
	}
	if !strings.Contains(page, tileHue("tim")) {
		t.Fatalf("initialen-fallback zonder kleur:\n%s", page)
	}
	if strings.Contains(page, `<img class="avatar sm"`) {
		t.Fatal("geen img voor gebruiker zonder avatar")
	}
	if os.Getenv("JOBCHIP_HOLD") != "" {
		jobURL := ts.URL + "/tim/demo/-/pipelines/" + strconv.FormatInt(pid, 10) + "/jobs/" + strconv.FormatInt(jobs[0].ID, 10)
		fmt.Fprintln(os.Stderr, "JOBCHIP_URL="+jobURL)
		for _, c := range client.Jar.Cookies(mustParse(t, ts.URL)) {
			fmt.Fprintf(os.Stderr, "JOBCHIP_COOKIE=%s=%s\n", c.Name, c.Value)
		}
		fmt.Fprintln(os.Stderr, "JOBCHIP_READY")
		select {}
	}
}

func TestStoreUserAvatarSkipsManual(t *testing.T) {
	st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	ctx := context.Background()
	u, err := st.UpsertUser(ctx, 9, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	if err := st.SetUserAvatar(ctx, u.ID, "/users/ada/avatar", "upload", "image/png"); err != nil {
		t.Fatal(err)
	}
	if _, err := st.UpsertUser(ctx, 9, "ada", "https://example/photo.png", false); err != nil {
		t.Fatal(err)
	}
	got, err := st.UserByID(ctx, u.ID)
	if err != nil {
		t.Fatal(err)
	}
	if got.AvatarURL != "/users/ada/avatar" || got.AvatarSource != "upload" {
		t.Fatalf("handmatige avatar overschreven: %+v", got)
	}
}

func TestStoreUserAvatarEntraRefresh(t *testing.T) {
	stateDir := t.TempDir()
	st, err := store.Open(filepath.Join(stateDir, "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	ctx := context.Background()
	u, err := st.UpsertUser(ctx, 11, "ada", "", false)
	if err != nil {
		t.Fatal(err)
	}
	srv := &Server{Cfg: config.Config{BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0"}, Store: st, StateDir: stateDir}
	if err := srv.storeUserAvatar(ctx, u, solidPNG(8, 8), "entra"); err != nil {
		t.Fatal(err)
	}
	got, err := st.UserByID(ctx, u.ID)
	if err != nil || got.AvatarSource != "entra" || got.AvatarURL != "/users/ada/avatar" {
		t.Fatalf("opslag: %+v %v", got, err)
	}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	res, err := http.Get(ts.URL + "/users/ada/avatar")
	if err != nil {
		t.Fatal(err)
	}
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	if res.StatusCode != 200 || res.Header.Get("Content-Type") != "image/png" || len(body) == 0 {
		t.Fatalf("serve %d %s %d", res.StatusCode, res.Header.Get("Content-Type"), len(body))
	}
	if err := st.SetUserAvatar(ctx, u.ID, got.AvatarURL, "upload", got.AvatarMIME); err != nil {
		t.Fatal(err)
	}
	fresh, _ := st.UserByID(ctx, u.ID)
	if err := srv.storeUserAvatar(ctx, fresh, solidPNG(4, 4), "entra"); err != nil {
		t.Fatal(err)
	}
	again, _ := st.UserByID(ctx, u.ID)
	if again.AvatarSource != "upload" {
		t.Fatalf("entra overschreef upload: %+v", again)
	}
}

func apiToken(t *testing.T, client *http.Client, base string) string {
	t.Helper()
	page := read(t, mustGet(t, client, base+"/settings"))
	page = read(t, mustPost(t, client, base+"/settings/tokens", url.Values{"csrf": {csrfOf(t, page)}, "name": {"api"}}))
	tok := between(page, `<p class="code">`, "</p>")
	if tok == "" {
		t.Fatal("geen token")
	}
	return tok
}

func solidPNG(w, h int) []byte {
	img := image.NewNRGBA(image.Rect(0, 0, w, h))
	for y := 0; y < h; y++ {
		for x := 0; x < w; x++ {
			img.SetNRGBA(x, y, color.NRGBA{R: 31, G: 111, B: 235, A: 255})
		}
	}
	var buf bytes.Buffer
	_ = png.Encode(&buf, img)
	return buf.Bytes()
}

func encodeICOFile(png []byte) []byte {
	buf := make([]byte, 6+16+len(png))
	buf[2] = 1
	buf[4] = 1
	buf[6] = 16
	buf[7] = 16
	n := uint32(len(png))
	buf[14] = byte(n)
	buf[15] = byte(n >> 8)
	buf[16] = byte(n >> 16)
	buf[17] = byte(n >> 24)
	off := uint32(22)
	buf[18] = byte(off)
	buf[19] = byte(off >> 8)
	copy(buf[22:], png)
	return buf
}
