package runner

import (
	"context"
	"time"

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

// Tier is één trede in de runnervolgorde van een job: de ingebouwde
// BlueGit-runner of een set aparte runners.
type Tier struct {
	Builtin bool
	Runners []store.Runner
}

// OfferTimeout: zo lang krijgen online aparte runners in een trede om een
// job op te pakken voordat de volgende trede aan de beurt is.
var OfferTimeout = 20 * time.Second

// Order berekent de volgorde puur uit de gegevens; zie Tiers.
//
// Accountrepo: eigen runners eerst (own_first) of de BlueGit-runner eerst
// en eigen runners alleen als die niet meteen vrij is (builtin_first).
// Groepsrepo: groepsrunners → account-runners van maintainers die
// toestemming gaven → BlueGit-runner; met builtinFirst staat de
// BlueGit-runner vooraan. Lege treden vallen weg.
func Order(ownerKind, userPref string, builtinFirst bool, own, group, optedIn []store.Runner) []Tier {
	var tiers []Tier
	add := func(t Tier) {
		if t.Builtin || len(t.Runners) > 0 {
			tiers = append(tiers, t)
		}
	}
	builtin := Tier{Builtin: true}
	if ownerKind == "group" {
		if builtinFirst {
			add(builtin)
		}
		add(Tier{Runners: group})
		add(Tier{Runners: optedIn})
		if !builtinFirst {
			add(builtin)
		}
		return tiers
	}
	if userPref == store.RunnerPrefOwnFirst {
		add(Tier{Runners: own})
		add(builtin)
	} else {
		add(builtin)
		add(Tier{Runners: own})
	}
	return tiers
}

// Tiers geeft de runnervolgorde voor een repo.
func Tiers(ctx context.Context, st *store.Store, repo store.Repo) ([]Tier, error) {
	if repo.OwnerKind == "group" {
		group, err := st.ListRunners(ctx, "group", repo.OwnerID)
		if err != nil {
			return nil, err
		}
		users, err := st.RunnerOptIns(ctx, repo.OwnerID)
		if err != nil {
			return nil, err
		}
		var opted []store.Runner
		for _, u := range users {
			// Toestemming geldt alleen zolang de gebruiker maintainer is.
			role, err := st.GroupRole(ctx, repo.OwnerID, u)
			if err != nil || !role.AtLeast(access.RoleMaintainer) {
				continue
			}
			rs, err := st.ListRunners(ctx, "user", u)
			if err != nil {
				return nil, err
			}
			opted = append(opted, rs...)
		}
		return Order("group", "", st.GroupBuiltinFirst(ctx, repo.OwnerID), nil, active(group), active(opted)), nil
	}
	own, err := st.ListRunners(ctx, "user", repo.OwnerID)
	if err != nil {
		return nil, err
	}
	return Order("user", st.UserRunnerPref(ctx, repo.OwnerID), false, active(own), nil, nil), nil
}

// active laat gepauzeerde (ook lokaal gepauzeerde) runners weg uit de volgorde.
func active(rs []store.Runner) []store.Runner {
	var out []store.Runner
	for _, r := range rs {
		if !r.Paused && !r.Draining {
			out = append(out, r)
		}
	}
	return out
}

func anyOnline(rs []store.Runner, now time.Time) bool {
	for _, r := range rs {
		if r.Online(now) {
			return true
		}
	}
	return false
}

// Step is de beslissing voor een wachtende job in deze tick.
type Step struct {
	Tier    int  // trede waar de job nu staat
	Builtin bool // nu ingebouwd starten
	Moved   bool // aanbod is verplaatst; opslaan
}

// Advance kiest wat er met een wachtende job gebeurt. builtinFree zegt of
// de ingebouwde runner nu een plek heeft. Elke trede wordt hooguit één
// keer per tick bekeken.
func Advance(tiers []Tier, tier int, offerAt, now time.Time, builtinFree bool) Step {
	n := len(tiers)
	if n == 0 {
		return Step{}
	}
	if tier < 0 || tier >= n {
		tier = 0
	}
	moved := offerAt.IsZero()
	if moved {
		offerAt = now
	}
	for i := 0; i < n; i++ {
		t := tiers[tier]
		if t.Builtin {
			if builtinFree {
				return Step{Tier: tier, Builtin: true, Moved: moved}
			}
		} else if anyOnline(t.Runners, now) && (now.Sub(offerAt) < OfferTimeout || i > 0 && moved) {
			return Step{Tier: tier, Moved: moved}
		}
		tier = (tier + 1) % n
		offerAt = now
		moved = true
	}
	return Step{Tier: tier, Moved: moved}
}

// RunnerInTier zegt of runner id in de trede staat.
func RunnerInTier(tiers []Tier, tier int, id int64) bool {
	if tier < 0 || tier >= len(tiers) {
		return false
	}
	for _, r := range tiers[tier].Runners {
		if r.ID == id {
			return true
		}
	}
	return false
}
