package server

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

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

type rvActor struct {
	name   string
	client *http.Client
	token  string
	member bool
	logged bool
}

func noRedirect() *http.Client {
	return &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
}

func rvGet(t *testing.T, c *http.Client, u, tok string) (int, string, http.Header) {
	t.Helper()
	req, _ := http.NewRequest("GET", u, nil)
	if tok != "" {
		req.Header.Set("Authorization", "Bearer "+tok)
	}
	res, err := c.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	return res.StatusCode, string(b), res.Header
}

// Releasezichtbaarheid: alle drie de keuzes x beide repo-zichtbaarheden x
// anoniem, niet-lid, lid, groepslid, tokens met en zonder rechten.
func TestReleaseVisibilityMatrix(t *testing.T) {
	e := newCIEnv(t)
	ctx := context.Background()
	st, base := e.st, e.ts.URL
	tim := e.user
	g, err := st.CreateGroup(ctx, tim.ID, "team", "team", "", access.RoleDeveloper)
	if err != nil {
		t.Fatal(err)
	}
	repo, err := st.CreateRepo(ctx, "group", g.ID, "lib", "Geheime bibliotheek.\nTweede regel met details", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	bare := gitrepo.Dir(e.srv.StoragePath(), repo.OwnerPath, repo.Name)
	if err := gitrepo.Init("git", bare, "master", "/bin/true"); err != nil {
		t.Fatal(err)
	}
	src := gitrepo.Dir(e.srv.StoragePath(), e.repo.OwnerPath, e.repo.Name)
	if out, err := exec.Command("git", "--git-dir", src, "push", "-q", bare, "master").CombinedOutput(); err != nil {
		t.Fatalf("push %v %s", err, out)
	}
	asset := filepath.Join(t.TempDir(), "app.bin")
	_ = os.WriteFile(asset, []byte("BINARY-RELEASE"), 0o644)
	if _, err := st.CreateRelease(ctx, repo.ID, "v1", e.sha, "Eerste", "Release-notes hier", tim.ID, 0, []store.ReleaseAsset{{Name: "app.bin", StoragePath: asset, Size: 14}}); err != nil {
		t.Fatal(err)
	}
	e.srv.StateDir = t.TempDir()
	if lp, err := e.srv.logoPath("repo", repo.ID); err == nil {
		_ = os.MkdirAll(filepath.Dir(lp), 0o755)
		_ = os.WriteFile(lp, []byte("\x89PNG\r\n\x1a\nlogo"), 0o644)
		_ = st.SetLogoMIME(ctx, "repo", repo.ID, "image/png")
	} else {
		t.Fatal(err)
	}
	pid, _ := st.CreatePipeline(ctx, repo.ID, e.sha, "refs/heads/master", "push", "tim", "init", []store.NewJob{{Name: "build", Stage: "build", Script: "true"}})

	out, _ := st.UpsertUser(ctx, 10, "outsider", "", false)
	mem, _ := st.UpsertUser(ctx, 11, "member", "", false)
	gm, _ := st.UpsertUser(ctx, 12, "groupie", "", false)
	if err := st.SetMember(ctx, "repo", repo.ID, "member", access.RoleReadonly); err != nil {
		t.Fatal(err)
	}
	if err := st.SetMember(ctx, "group", g.ID, "groupie", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}
	sc := func(uid int64) *http.Client {
		c, _ := sessionClient(t, st, base, uid)
		return c
	}
	actors := []rvActor{
		{name: "anon", client: noRedirect()},
		{name: "outsider", client: sc(out.ID), token: issue(t, st, out.ID, "api"), logged: true},
		{name: "member", client: sc(mem.ID), token: issue(t, st, mem.ID, "api"), member: true, logged: true},
		{name: "groupie", client: sc(gm.ID), token: issue(t, st, gm.ID, "api"), member: true, logged: true},
	}
	memberRunnerTok := issue(t, st, mem.ID, "runners") // token zonder lees-API-rechten

	// Warm de leescache als lid, zodat een lek via de cache zou opvallen.
	e.srv.SetReadCache(nil)

	code := []string{"/-/tree", "/-/blob/README.md", "/-/commits", "/-/branches", "/-/tags", "/-/issues", "/-/merge-requests",
		"/-/pipelines", "/-/pipelines/" + itoa(pid), "/-/archive/master/lib-master.zip", "/-/archive/master/lib-master.tar.gz",
		"/-/tags/archive?tag=v1&format=zip", "/-/branches/archive?branch=master&format=tar.gz", "/-/commit/" + e.sha, "/-/settings"}
	apiCode := []string{"", "/repository/tree", "/repository/commits", "/repository/files/README.md/raw?ref=master", "/pipelines", "/issues",
		"/repository/tags/v1/archive"}

	for _, rv := range []string{"private", "public"} {
		for _, relv := range []string{"inherit", "private", "public"} {
			if err := st.UpdateRepo(ctx, repo.ID, repo.Description, rv); err != nil {
				t.Fatal(err)
			}
			if err := st.SetReleaseVisibility(ctx, repo.ID, relv); err != nil {
				t.Fatal(err)
			}
			relPublic := relv == "public" || (relv == "inherit" && rv == "public")
			label := "repo=" + rv + " releases=" + relv
			for _, a := range actors {
				canRel := a.member || relPublic
				canCode := a.member || rv == "public"
				// Releases-pagina en asset (web, ook zoals een PKGBUILD ze haalt).
				c, body, _ := rvGet(t, a.client, base+"/team/lib/-/releases", "")
				if canRel != (c == 200) {
					t.Errorf("%s %s releases-pagina: %d", label, a.name, c)
				}
				if c == 200 && !strings.Contains(body, "Release-notes hier") {
					t.Errorf("%s %s mist notities", label, a.name)
				}
				if c == 200 && !canCode {
					for _, bad := range []string{"/team/lib/-/tree", "/team/lib/-/pipelines", "/team/lib/-/commits", "/-/archive/", e.sha[:8], "Tweede regel", "lib.git"} {
						if strings.Contains(body, bad) {
							t.Errorf("%s %s releases-pagina lekt %q", label, a.name, bad)
						}
					}
				}
				c, body, _ = rvGet(t, a.client, base+"/team/lib/-/releases/v1/assets/app.bin", "")
				if canRel != (c == 200 && body == "BINARY-RELEASE") {
					t.Errorf("%s %s asset: %d", label, a.name, c)
				}
				// Release-API, anoniem of met token.
				c, body, _ = rvGet(t, http.DefaultClient, base+"/api/v1/projects/team/lib/releases", a.token)
				if canRel != (c == 200) {
					t.Errorf("%s %s api releases: %d %s", label, a.name, c, body)
				}
				if c == 200 && !canCode && (strings.Contains(body, e.sha) || strings.Contains(body, "archive")) {
					t.Errorf("%s %s api lekt commit/archief: %s", label, a.name, body)
				}
				c, body, _ = rvGet(t, http.DefaultClient, base+"/api/v1/projects/team/lib/releases/v1/assets/app.bin", a.token)
				if canRel != (c == 200 && body == "BINARY-RELEASE") {
					t.Errorf("%s %s api asset: %d", label, a.name, c)
				}
				// Code, archieven, pipelines, instellingen: nooit via releases.
				for _, p := range code {
					c, _, _ := rvGet(t, a.client, base+"/team/lib"+p, "")
					if !canCode && c < 400 {
						t.Errorf("%s %s ziet %s: %d", label, a.name, p, c)
					}
				}
				for _, p := range apiCode {
					c, _, _ := rvGet(t, http.DefaultClient, base+"/api/v1/projects/team/lib"+p, a.token)
					if !canCode && c < 400 {
						t.Errorf("%s %s api ziet %s: %d", label, a.name, p, c)
					}
				}
				c, _, _ = rvGet(t, http.DefaultClient, base+"/team/lib.git/info/refs?service=git-upload-pack", a.token)
				if !canCode && c < 400 {
					t.Errorf("%s %s git clone: %d", label, a.name, c)
				}
				if a.member && c != 200 {
					t.Errorf("%s %s lid kan niet clonen: %d", label, a.name, c)
				}
				// Projectpagina: release-only gaat naar Releases.
				c, _, h := rvGet(t, a.client, base+"/team/lib", "")
				if !canCode && relPublic {
					if c != http.StatusSeeOther || h.Get("Location") != "/team/lib/-/releases" {
						t.Errorf("%s %s projectpagina: %d %s", label, a.name, c, h.Get("Location"))
					}
				} else if canCode && c != 200 {
					t.Errorf("%s %s projectpagina: %d", label, a.name, c)
				}
				// Varianten van de projectroot (t695u): /, /- en /-/.
				for _, suf := range []string{"/", "/-", "/-/"} {
					c, _, h := rvGet(t, a.client, base+"/team/lib"+suf, "")
					loc := h.Get("Location")
					switch {
					case !canCode && relPublic:
						if c != http.StatusSeeOther || loc != "/team/lib/-/releases" {
							t.Errorf("%s %s %s: %d %s", label, a.name, suf, c, loc)
						}
					case canCode:
						if c != http.StatusSeeOther || loc != "/team/lib" {
							t.Errorf("%s %s %s: %d %s", label, a.name, suf, c, loc)
						}
					default:
						if c < 400 {
							t.Errorf("%s %s %s lekt: %d %s", label, a.name, suf, c, loc)
						}
					}
				}
				// /-/releases/ met slash gedraagt zich als zonder.
				c, _, h = rvGet(t, a.client, base+"/team/lib/-/releases/", "")
				if canRel && (c != http.StatusSeeOther || h.Get("Location") != "/team/lib/-/releases") || !canRel && c < 400 {
					t.Errorf("%s %s releases/: %d %s", label, a.name, c, h.Get("Location"))
				}
				// HEAD (curl -I) gedraagt zich als GET op de projectroot.
				for _, suf := range []string{"", "/", "/-"} {
					req, _ := http.NewRequest(http.MethodHead, base+"/team/lib"+suf, nil)
					if res, err := a.client.Do(req); err == nil {
						res.Body.Close()
						if !canCode && relPublic && (res.StatusCode != http.StatusSeeOther || res.Header.Get("Location") != "/team/lib/-/releases") {
							t.Errorf("%s %s HEAD %s: %d", label, a.name, suf, res.StatusCode)
						}
					}
				}
				// Repo-logo volgt de Releases-regel (t701u).
				c, _, _ = rvGet(t, a.client, base+"/team/lib/-/logo", "")
				if seeLogo := canRel || canCode; seeLogo && c != 200 || !seeLogo && c < 400 {
					t.Errorf("%s %s logo: %d", label, a.name, c)
				}
				// Niet-bestaand blijft 404; open redirect via dubbele slash kan niet.
				for _, p := range []string{"/team/nope", "/team/nope/", "/team/nope/-", "//evil.example/x/-"} {
					if c, _, h := rvGet(t, a.client, base+p, ""); c != 404 && !strings.HasPrefix(h.Get("Location"), "/") || strings.HasPrefix(h.Get("Location"), "//") {
						t.Errorf("%s %s %s: %d %s", label, a.name, p, c, h.Get("Location"))
					}
				}
				// Lid: tabbladen; publieke code met privé releases: geen Releases-tab.
				if canCode {
					_, body, _ := rvGet(t, a.client, base+"/team/lib/-/tree", "")
					if has := strings.Contains(body, `href="/team/lib/-/releases"`); has != canRel {
						t.Errorf("%s %s releases-tab zichtbaar=%v", label, a.name, has)
					}
				}
			}
			// Token zonder lees-API-rechten krijgt geen privé releases.
			if !relPublic {
				if c, _, _ := rvGet(t, http.DefaultClient, base+"/api/v1/projects/team/lib/releases", memberRunnerTok); c == 200 {
					t.Errorf("%s runners-token leest releases", label)
				}
			}
			// Verkennen: alleen naam en korte beschrijving.
			_, home, _ := rvGet(t, noRedirect(), base+"/", "")
			listed := strings.Contains(home, `href="/team/lib/-/releases"`)
			if listed != (rv == "private" && relv == "public") {
				t.Errorf("%s verkennen toont release-only=%v", label, listed)
			}
			if listed && (strings.Contains(home, "Tweede regel") || !strings.Contains(home, "Geheime bibliotheek.")) {
				t.Errorf("%s verkennen beschrijving fout", label)
			}
		}
	}
}

// Instelling via UI en API; alleen beheerders; ongeldige waarde geweigerd;
// ontbrekende velden blijven ongewijzigd.
func TestReleaseVisibilitySetting(t *testing.T) {
	e := newCIEnv(t)
	ctx := context.Background()
	st, base := e.st, e.ts.URL
	tc, csrf := sessionClient(t, st, base, e.user.ID)
	_, page, _ := rvGet(t, tc, base+"/tim/app/-/settings", "")
	if !strings.Contains(page, `name="release_visibility"`) || !strings.Contains(page, `tip "`) && !strings.Contains(page, `class="tip"`) {
		t.Fatalf("instelling of tooltip ontbreekt")
	}
	res, err := tc.PostForm(base+"/tim/app/-/settings", url.Values{"csrf": {csrf}, "description": {"d"}, "visibility": {"private"}, "release_visibility": {"public"}})
	if err != nil {
		t.Fatal(err)
	}
	res.Body.Close()
	if r, _ := st.RepoByID(ctx, e.repo.ID); r.ReleaseVisibility != "public" || r.Visibility != "private" {
		t.Fatalf("ui opslaan: %+v", r)
	}
	tok := issue(t, st, e.user.ID, "api")
	c, b := rapi(t, base, tok, "PUT", "/projects/tim/app", map[string]any{"release_visibility": "private"})
	if c != 200 || !strings.Contains(string(b), `"release_visibility":"private"`) || !strings.Contains(string(b), `"visibility":"private"`) || !strings.Contains(string(b), `"description":"d"`) {
		t.Fatalf("api %d %s", c, b)
	}
	if c, _ := rapi(t, base, tok, "PUT", "/projects/tim/app", map[string]any{"release_visibility": "wereld"}); c != 400 {
		t.Fatalf("ongeldig %d", c)
	}
	bob, _ := st.UpsertUser(ctx, 5, "bob", "", false)
	_ = st.SetMember(ctx, "repo", e.repo.ID, "bob", access.RoleDeveloper)
	if c, _ := rapi(t, base, issue(t, st, bob.ID, "api"), "PUT", "/projects/tim/app", map[string]any{"release_visibility": "public"}); c != 403 {
		t.Fatalf("developer mag zetten: %d", c)
	}
	if r, _ := st.RepoByID(ctx, e.repo.ID); r.ReleaseVisibility != "private" {
		t.Fatalf("na weigering: %s", r.ReleaseVisibility)
	}
}

// De sociale kaart van een release-only repo leest nooit code.
func TestReleaseOnlyCard(t *testing.T) {
	e := newCIEnv(t)
	ctx := context.Background()
	_ = e.st.SetReleaseVisibility(ctx, e.repo.ID, "public")
	r := e.srv.cardForPath(ctx, "/tim/app/-/releases", "", "")
	if r.Meta.Kind != "release" || strings.Contains(r.Meta.Description+strings.Join(r.Meta.Facts, " "), "hello from the repo") {
		t.Fatalf("kaart: %+v", r.Meta)
	}
	if r := e.srv.cardForPath(ctx, "/tim/app/-/tree", "", ""); r.Meta.Kind == "repo" {
		t.Fatalf("code-kaart voor release-only: %+v", r.Meta)
	}
}
