package runner

import (
	"context"
	"path/filepath"
	"testing"

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

// Jobs op beschermde refs: alleen ingebouwd, globaal, groepsrunner en
// account-runners van maintainers/admins. Niet-beschermd: zoals voorheen.
func TestProtectedRefRunners(t *testing.T) {
	s, err := store.Open(filepath.Join(t.TempDir(), "b.db"), make([]byte, 32))
	if err != nil {
		t.Fatal(err)
	}
	defer s.Close()
	ctx := context.Background()
	tim, _ := s.UpsertUser(ctx, 1, "tim", "", false)
	_, _ = s.UpsertUser(ctx, 2, "dev", "", false)
	_, _ = s.UpsertUser(ctx, 3, "boss", "", false)
	adm, _ := s.UpsertUser(ctx, 4, "adm", "", false)
	if _, err := s.SetInstanceAdmin(ctx, tim.ID, adm.ID, true); err != nil {
		t.Fatal(err)
	}
	g, _ := s.CreateGroup(ctx, tim.ID, "Team", "team", "", access.RoleReadonly)
	_ = s.SetMember(ctx, "group", g.ID, "dev", access.RoleDeveloper)
	_ = s.SetMember(ctx, "group", g.ID, "boss", access.RoleMaintainer)
	_ = s.SetMember(ctx, "group", g.ID, "adm", access.RoleReadonly)
	repo, _ := s.CreateRepo(ctx, "group", g.ID, "app", "", "master", "private")
	reg := func(kind string, id int64, name string) store.Runner {
		tok, _ := s.CreateRunnerRegToken(ctx, kind, id, tim.ID)
		rn, _, err := s.RegisterRunner(ctx, tok, name, "test")
		if err != nil {
			t.Fatal(err)
		}
		return rn
	}
	u := func(n string) int64 { x, _ := s.UserByUsername(ctx, n); return x.ID }
	reg("group", g.ID, "grp")
	reg(store.RunnerGlobal, 0, "glob")
	devRn := reg("user", u("dev"), "dev-pc")
	bossRn := reg("user", u("boss"), "boss-pc")
	admRn := reg("user", adm.ID, "adm-pc")
	for _, n := range []string{"dev", "boss", "adm"} {
		_ = s.SetRunnerOptIn(ctx, g.ID, u(n), true)
	}
	tiers, _ := Tiers(ctx, s, repo, false)
	eq(t, names(tiers), "glob", "grp", "dev-pc+boss-pc+adm-pc", "builtin")
	tiers, _ = Tiers(ctx, s, repo, true)
	eq(t, names(tiers), "glob", "grp", "boss-pc+adm-pc", "builtin")
	if ex := ExcludedForProtected(ctx, s, repo); len(ex) != 1 || ex[0] != "dev-pc" {
		t.Fatalf("excluded: %v", ex)
	}
	r := &Runner{Store: s}
	if r.mayRun(ctx, devRn, repo, true) || !r.mayRun(ctx, devRn, repo, false) {
		t.Fatal("dev runner: protected no, unprotected yes")
	}
	if !r.mayRun(ctx, bossRn, repo, true) || !r.mayRun(ctx, admRn, repo, true) {
		t.Fatal("maintainer/admin runner must run protected")
	}
	// Ingetrokken: boss wordt developer → meteen niet meer voor beschermd.
	if err := s.SetMember(ctx, "group", g.ID, "boss", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}
	// Een nieuwe groepsrepo kan expliciete repo-rollen hebben; die ook omlaag.
	_ = s.SetMember(ctx, "repo", repo.ID, "boss", access.RoleDeveloper)
	if role, _ := s.EffectiveRole(ctx, u("boss"), repo.ID); role.AtLeast(access.RoleMaintainer) {
		t.Fatalf("boss role %s", role)
	}
	if r.mayRun(ctx, bossRn, repo, true) {
		t.Fatal("demoted boss still runs protected")
	}
	tiers, _ = Tiers(ctx, s, repo, true)
	eq(t, names(tiers), "glob", "grp", "adm-pc", "builtin")
	// Alleen opt-in-runners van developers: de beschermde job valt door
	// naar groep/ingebouwd, nooit naar dev-pc.
	_ = s.SetRunnerOptIn(ctx, g.ID, adm.ID, false)
	tiers, _ = Tiers(ctx, s, repo, true)
	eq(t, names(tiers), "glob", "grp", "builtin")
}
