package server

import (
	"context"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/runner"
)

// Een lopende job leest de eigen privérepo met CI_JOB_TOKEN (git en API),
// maar geen andere repo, niet schrijven, en niet meer na afloop.
func TestJobTokenReadsOwnRepo(t *testing.T) {
	e := newCIEnv(t)
	ctx := context.Background()
	st, base := e.st, e.ts.URL
	other, err := st.CreateRepo(ctx, "user", e.user.ID, "other", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	if err := gitrepo.Init("git", gitrepo.Dir(e.srv.StoragePath(), other.OwnerPath, other.Name), "master", "/bin/true"); err != nil {
		t.Fatal(err)
	}
	pid := e.pipeline()
	jobs, _ := st.JobsByPipeline(ctx, pid)
	tok, err := st.CreateJobToken(ctx, jobs[0].ID)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.MarkJobRunning(ctx, jobs[0].ID); err != nil {
		t.Fatal(err)
	}
	own := base + "/tim/app"
	// Precies de config die de runner de job meegeeft (GIT_CONFIG_*).
	env := map[string]string{}
	runner.JobGitAuth(env, own, tok)
	git := func(args ...string) (string, error) {
		cmd := exec.Command("git", args...)
		cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_ASKPASS=/bin/false")
		for k, v := range env {
			cmd.Env = append(cmd.Env, k+"="+v)
		}
		out, err := cmd.CombinedOutput()
		return string(out), err
	}
	for _, u := range []string{own + ".git"} {
		if out, err := git("ls-remote", u); err != nil || !strings.Contains(out, e.sha) {
			t.Fatalf("ls-remote %s: %v %s", u, err, out)
		}
	}
	dir := filepath.Join(t.TempDir(), "c")
	if out, err := git("clone", "-q", own+".git", dir); err != nil {
		t.Fatalf("clone: %v %s", err, out)
	}
	if out, err := git("-C", dir, "fetch", "-q", "origin"); err != nil {
		t.Fatalf("fetch: %v %s", err, out)
	}
	if out, err := git("-C", dir, "push", "-q", "origin", "HEAD:refs/heads/x"); err == nil {
		t.Fatalf("push with job token must fail: %s", out)
	}
	// De header geldt alleen voor de eigen URL; met het token expliciet
	// erbij kan een andere repo ook niet.
	if out, err := git("-c", "http.extraHeader=Authorization: Bearer "+tok, "ls-remote", base+"/tim/other.git"); err == nil {
		t.Fatalf("other repo readable: %s", out)
	}
	api := func(path string) int {
		req, _ := http.NewRequest("GET", base+"/api/v1"+path, nil)
		req.Header.Set("Authorization", "Bearer "+tok)
		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			t.Fatal(err)
		}
		resp.Body.Close()
		return resp.StatusCode
	}
	if c := api("/projects/tim/app"); c != 200 {
		t.Fatalf("api own: %d", c)
	}
	if c := api("/projects/tim/other"); c == 200 {
		t.Fatalf("api other: %d", c)
	}
	if c := api("/user"); c == 200 {
		t.Fatalf("api user: %d", c)
	}
	// Na afloop vervalt alles.
	if err := st.FinishJob(ctx, jobs[0].ID, "success", ""); err != nil {
		t.Fatal(err)
	}
	if out, err := git("ls-remote", own+".git"); err == nil {
		t.Fatalf("ls-remote after job: %s", out)
	}
	if c := api("/projects/tim/app"); c == 200 {
		t.Fatalf("api after job: %d", c)
	}
}
