package runner

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

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

// Globale runners staan vóór alles (ook vóór de ingebouwde runner), voor
// publieke én privé repo's van accounts en groepen; offline wordt overgeslagen.
func TestGlobalRunners(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)
	g, _ := s.CreateGroup(ctx, tim.ID, "Team", "team", "", access.RoleReadonly)
	priv, _ := s.CreateRepo(ctx, "user", tim.ID, "secret", "", "master", "private")
	pub, _ := s.CreateRepo(ctx, "user", tim.ID, "open", "", "master", "public")
	grepo, _ := s.CreateRepo(ctx, "group", g.ID, "app", "", "master", "private")
	reg := func(kind string, id int64, name string) store.Runner {
		tok, err := s.CreateRunnerRegToken(ctx, kind, id, tim.ID)
		if err != nil {
			t.Fatal(err)
		}
		rn, _, err := s.RegisterRunner(ctx, tok, name, "test")
		if err != nil {
			t.Fatal(err)
		}
		return rn
	}
	reg("user", tim.ID, "tim-pc")
	reg("group", g.ID, "grp")
	glob := reg(store.RunnerGlobal, 0, "global-1")

	tiers, _ := Tiers(ctx, s, priv, false)
	eq(t, names(tiers), "global-1", "builtin", "tim-pc")
	tiers, _ = Tiers(ctx, s, pub, false)
	eq(t, names(tiers), "global-1", "builtin", "tim-pc")
	tiers, _ = Tiers(ctx, s, grepo, false)
	eq(t, names(tiers), "global-1", "grp", "builtin")

	r := &Runner{Store: s}
	for _, repo := range []store.Repo{priv, pub, grepo} {
		if !r.mayRun(ctx, glob, repo, false) {
			t.Fatalf("global runner may run %s", repo.Name)
		}
	}
	// Offline globale runner: de job gaat meteen door naar de volgende trede.
	off := glob
	off.LastSeen = time.Now().Add(-time.Hour)
	st := Advance([]Tier{{Runners: []store.Runner{off}}, {Builtin: true}}, 0, time.Time{}, time.Now(), true)
	if !st.Builtin || st.Tier != 1 {
		t.Fatalf("offline global not skipped: %+v", st)
	}
	// Gepauzeerd: valt uit de volgorde.
	paused := true
	if _, err := s.UpdateRunner(ctx, store.RunnerGlobal, 0, glob.ID, nil, &paused); err != nil {
		t.Fatal(err)
	}
	tiers, _ = Tiers(ctx, s, priv, false)
	eq(t, names(tiers), "builtin", "tim-pc")
}
