package runner

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

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

func names(tiers []Tier) []string {
	var out []string
	for _, t := range tiers {
		if t.Builtin {
			out = append(out, "builtin")
			continue
		}
		s := ""
		for i, r := range t.Runners {
			if i > 0 {
				s += "+"
			}
			s += r.Name
		}
		out = append(out, s)
	}
	return out
}

func eq(t *testing.T, got []string, want ...string) {
	t.Helper()
	if len(got) != len(want) {
		t.Fatalf("got %v, want %v", got, want)
	}
	for i := range got {
		if got[i] != want[i] {
			t.Fatalf("got %v, want %v", got, want)
		}
	}
}

func TestOrder(t *testing.T) {
	own := []store.Runner{{ID: 1, Name: "laptop"}}
	grp := []store.Runner{{ID: 2, Name: "grp"}}
	opt := []store.Runner{{ID: 3, Name: "maint"}}
	eq(t, names(Order("user", store.RunnerPrefOwnFirst, false, own, nil, nil)), "laptop", "builtin")
	eq(t, names(Order("user", store.RunnerPrefBuiltinFirst, false, own, nil, nil)), "builtin", "laptop")
	eq(t, names(Order("user", "", false, own, nil, nil)), "builtin", "laptop")
	eq(t, names(Order("user", store.RunnerPrefOwnFirst, false, nil, nil, nil)), "builtin")
	eq(t, names(Order("group", "", false, nil, grp, opt)), "grp", "maint", "builtin")
	eq(t, names(Order("group", "", true, nil, grp, opt)), "builtin", "grp", "maint")
	eq(t, names(Order("group", "", false, nil, nil, opt)), "maint", "builtin")
	eq(t, names(Order("group", "", false, nil, grp, nil)), "grp", "builtin")
}

func TestAdvance(t *testing.T) {
	now := time.Now()
	on := store.Runner{ID: 1, Name: "on", LastSeen: now}
	off := store.Runner{ID: 2, Name: "off", LastSeen: now.Add(-time.Hour)}
	remoteOn := Tier{Runners: []store.Runner{on}}
	remoteOff := Tier{Runners: []store.Runner{off}}
	builtin := Tier{Builtin: true}

	// Eigen runners eerst, runner online: blijft op de runner wachten.
	st := Advance([]Tier{remoteOn, builtin}, 0, time.Time{}, now, true)
	if st.Builtin || st.Tier != 0 || !st.Moved {
		t.Fatalf("own first online: %+v", st)
	}
	// Na de wachttijd gaat de job naar de BlueGit-runner.
	st = Advance([]Tier{remoteOn, builtin}, 0, now.Add(-OfferTimeout-time.Second), now, true)
	if !st.Builtin || st.Tier != 1 {
		t.Fatalf("own first timeout: %+v", st)
	}
	// Runner offline: meteen door.
	st = Advance([]Tier{remoteOff, builtin}, 0, time.Time{}, now, true)
	if !st.Builtin || st.Tier != 1 {
		t.Fatalf("offline: %+v", st)
	}
	// BlueGit-runner eerst maar vol: door naar de eigen runner.
	st = Advance([]Tier{builtin, remoteOn}, 0, time.Time{}, now, false)
	if st.Builtin || st.Tier != 1 || !st.Moved {
		t.Fatalf("builtin busy: %+v", st)
	}
	// BlueGit-runner eerst en vrij: direct.
	st = Advance([]Tier{builtin, remoteOn}, 0, time.Time{}, now, true)
	if !st.Builtin || st.Tier != 0 {
		t.Fatalf("builtin free: %+v", st)
	}
	// Groep: groepsrunner offline, maintainer-runner online → wacht daar.
	st = Advance([]Tier{remoteOff, remoteOn, builtin}, 0, time.Time{}, now, true)
	if st.Builtin || st.Tier != 1 {
		t.Fatalf("group fallback: %+v", st)
	}
	// Alles bezet en offline: rondje, eindigt weer bij een trede, start niets.
	st = Advance([]Tier{builtin, remoteOff}, 0, time.Time{}, now, false)
	if st.Builtin {
		t.Fatalf("nothing free: %+v", st)
	}
	// Wrap: maintainer-runner timeout, builtin vol → terug naar de groepsrunner (online).
	st = Advance([]Tier{remoteOn, builtin}, 1, now, now, false)
	if st.Builtin || st.Tier != 0 {
		t.Fatalf("wrap: %+v", st)
	}
}

func TestTiersAndPrivacy(t *testing.T) {
	dir := t.TempDir()
	s, err := store.Open(filepath.Join(dir, "b.db"), make([]byte, 32))
	if err != nil {
		t.Fatal(err)
	}
	defer s.Close()
	ctx := context.Background()
	tim, _ := s.UpsertUser(ctx, 1, "tim", "", false)
	bob, _ := s.UpsertUser(ctx, 2, "bob", "", false)
	carol, _ := s.UpsertUser(ctx, 3, "carol", "", false)
	g, err := s.CreateGroup(ctx, tim.ID, "Team", "team", "", access.RoleReadonly)
	if err != nil {
		t.Fatal(err)
	}
	if err := s.SetMember(ctx, "group", g.ID, "bob", access.RoleDeveloper); err != nil {
		t.Fatal(err)
	}
	if err := s.SetMember(ctx, "group", g.ID, "carol", access.RoleMaintainer); err != nil {
		t.Fatal(err)
	}
	grepo, err := s.CreateRepo(ctx, "group", g.ID, "app", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	trepo, err := s.CreateRepo(ctx, "user", tim.ID, "secret", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	reg := func(kind string, id int64, name string) store.Runner {
		tok, err := s.CreateRunnerRegToken(ctx, kind, id, id)
		if err != nil {
			t.Fatal(err)
		}
		rn, _, err := s.RegisterRunner(ctx, tok, name, "test")
		if err != nil {
			t.Fatal(err)
		}
		if _, _, err := s.RegisterRunner(ctx, tok, "again", "test"); err == nil {
			t.Fatal("registration token reused")
		}
		return rn
	}
	grn := reg("group", g.ID, "grp")
	bobRn := reg("user", bob.ID, "bob-pc")
	carolRn := reg("user", carol.ID, "carol-pc")
	timRn := reg("user", tim.ID, "tim-pc")
	_ = s.SetRunnerOptIn(ctx, g.ID, bob.ID, true)   // geen maintainer: telt niet
	_ = s.SetRunnerOptIn(ctx, g.ID, carol.ID, true) // maintainer: telt
	tiers, err := Tiers(ctx, s, grepo)
	if err != nil {
		t.Fatal(err)
	}
	eq(t, names(tiers), "grp", "carol-pc", "builtin")
	_ = s.SetGroupBuiltinFirst(ctx, g.ID, true)
	tiers, _ = Tiers(ctx, s, grepo)
	eq(t, names(tiers), "builtin", "grp", "carol-pc")

	tiers, _ = Tiers(ctx, s, trepo)
	eq(t, names(tiers), "builtin", "tim-pc")
	_ = s.SetUserRunnerPref(ctx, tim.ID, store.RunnerPrefOwnFirst)
	tiers, _ = Tiers(ctx, s, trepo)
	eq(t, names(tiers), "tim-pc", "builtin")

	// Gepauzeerd: valt uit de volgorde, blijft in de lijst.
	paused := true
	if _, err := s.UpdateRunner(ctx, "user", carol.ID, carolRn.ID, nil, &paused); err != nil {
		t.Fatal(err)
	}
	_ = s.SetGroupBuiltinFirst(ctx, g.ID, false)
	tiers, _ = Tiers(ctx, s, grepo)
	eq(t, names(tiers), "grp", "builtin")
	if rs, _ := s.ListRunners(ctx, "user", carol.ID); len(rs) != 1 || !rs[0].Paused {
		t.Fatal("paused runner listed")
	}
	if _, err := s.UpdateRunner(ctx, "user", tim.ID, carolRn.ID, nil, &paused); err == nil {
		t.Fatal("tim paused carol's runner")
	}

	r := &Runner{Store: s}
	if !r.mayRun(ctx, grn, grepo) || r.mayRun(ctx, grn, trepo) {
		t.Fatal("group runner scope")
	}
	if !r.mayRun(ctx, carolRn, grepo) || r.mayRun(ctx, carolRn, trepo) {
		t.Fatal("carol scope")
	}
	if r.mayRun(ctx, bobRn, trepo) {
		t.Fatal("bob may not run tim's private repo")
	}
	if !r.mayRun(ctx, timRn, trepo) {
		t.Fatal("tim runs own repo")
	}
	// Ingetrokken runner verdwijnt uit de volgorde en zijn token werkt niet meer.
	if err := s.RevokeRunner(ctx, "user", tim.ID, timRn.ID); err != nil {
		t.Fatal(err)
	}
	tiers, _ = Tiers(ctx, s, trepo)
	eq(t, names(tiers), "builtin")
}
