package store

import (
	"context"
	"database/sql"
	"errors"
	"strings"
	"time"
)

// Runner is een aparte bluegit-runner op een eigen machine, gekoppeld aan
// een account (owner_kind user) of een groep (owner_kind group).
type Runner struct {
	ID        int64
	OwnerKind string
	OwnerID   int64
	Name      string
	CreatedAt time.Time
	LastSeen  time.Time
	Version   string
	Revoked   bool
	Paused    bool
	// Draining: de runner zelf staat lokaal op pauze (drain); lopende jobs lopen af.
	Draining bool
}

// RunnerOnlineWindow: zo lang na de laatste heartbeat telt een runner als online.
const RunnerOnlineWindow = 90 * time.Second

// Online zegt of de runner recent contact had.
func (r Runner) Online(now time.Time) bool {
	return !r.Revoked && !r.LastSeen.IsZero() && now.Sub(r.LastSeen) < RunnerOnlineWindow
}

// Runner-voorkeuren van een account.
const (
	RunnerPrefOwnFirst     = "own_first"
	RunnerPrefBuiltinFirst = "builtin_first"
)

// ErrRegToken is een onbekend, gebruikt of verlopen registratietoken.
var ErrRegToken = errors.New("registration token invalid or expired")

// RunnerGlobal is een runner van de instance (owner_id 0), door beheerders
// geregistreerd, voor jobs uit alle repo's.
const RunnerGlobal = "global"

// CreateRunnerRegToken maakt een eenmalig registratietoken (24 uur geldig).
func (s *Store) CreateRunnerRegToken(ctx context.Context, ownerKind string, ownerID, by int64) (string, error) {
	plain, err := newToken("bgrr_")
	if err != nil {
		return "", err
	}
	exp := time.Now().Add(24 * time.Hour).UTC().Format(time.RFC3339)
	_, err = s.db.ExecContext(ctx, `INSERT INTO runner_reg_tokens (owner_kind, owner_id, token_hash, created_by, expires_at) VALUES (?, ?, ?, ?, ?)`,
		ownerKind, ownerID, hashToken(plain), by, exp)
	return plain, err
}

// RegisterRunner wisselt een registratietoken in voor een runner en zijn
// eigen runner-token (bgr_). Alleen de hash wordt bewaard.
func (s *Store) RegisterRunner(ctx context.Context, regToken, name, version string) (Runner, string, error) {
	tx, err := s.db.BeginTx(ctx, nil)
	if err != nil {
		return Runner{}, "", err
	}
	defer func() { _ = tx.Rollback() }()
	var id, ownerID, by int64
	var kind, exp string
	err = tx.QueryRowContext(ctx, `SELECT id, owner_kind, owner_id, created_by, expires_at FROM runner_reg_tokens WHERE token_hash = ? AND used = 0`, hashToken(regToken)).Scan(&id, &kind, &ownerID, &by, &exp)
	if err != nil || parseTime(exp).Before(time.Now()) {
		return Runner{}, "", ErrRegToken
	}
	if _, err := tx.ExecContext(ctx, `UPDATE runner_reg_tokens SET used = 1 WHERE id = ?`, id); err != nil {
		return Runner{}, "", err
	}
	plain, err := newToken("bgr_")
	if err != nil {
		return Runner{}, "", err
	}
	name = strings.TrimSpace(name)
	if name == "" {
		name = "runner"
	}
	if len(name) > 80 {
		name = name[:80]
	}
	at := now()
	res, err := tx.ExecContext(ctx, `INSERT INTO runners (owner_kind, owner_id, name, token_hash, created_by, created_at, last_seen, version) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
		kind, ownerID, name, hashToken(plain), by, at, at, version)
	if err != nil {
		return Runner{}, "", err
	}
	rid, _ := res.LastInsertId()
	if err := tx.Commit(); err != nil {
		return Runner{}, "", err
	}
	return Runner{ID: rid, OwnerKind: kind, OwnerID: ownerID, Name: name, CreatedAt: parseTime(at), LastSeen: parseTime(at), Version: version}, plain, nil
}

const runnerCols = `id, owner_kind, owner_id, name, created_at, last_seen, version, revoked, paused, draining`

func scanRunner(sc interface{ Scan(...any) error }) (Runner, error) {
	var r Runner
	var created, seen string
	var revoked, paused, draining int
	if err := sc.Scan(&r.ID, &r.OwnerKind, &r.OwnerID, &r.Name, &created, &seen, &r.Version, &revoked, &paused, &draining); err != nil {
		return Runner{}, err
	}
	r.CreatedAt, r.LastSeen, r.Revoked, r.Paused, r.Draining = parseTime(created), parseTime(seen), revoked == 1, paused == 1, draining == 1
	return r, nil
}

// RunnerByToken geeft de runner bij een bgr_-token. Ingetrokken telt niet.
func (s *Store) RunnerByToken(ctx context.Context, token string) (Runner, error) {
	if !strings.HasPrefix(token, "bgr_") {
		return Runner{}, errNotFound
	}
	r, err := scanRunner(s.db.QueryRowContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE token_hash = ? AND revoked = 0`, hashToken(token)))
	if errors.Is(err, sql.ErrNoRows) {
		return Runner{}, errNotFound
	}
	return r, err
}

// RunnerByID geeft één runner.
func (s *Store) RunnerByID(ctx context.Context, id int64) (Runner, error) {
	r, err := scanRunner(s.db.QueryRowContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE id = ?`, id))
	if errors.Is(err, sql.ErrNoRows) {
		return Runner{}, errNotFound
	}
	return r, err
}

// TouchRunner is de heartbeat.
func (s *Store) TouchRunner(ctx context.Context, id int64, version string) error {
	_, err := s.db.ExecContext(ctx, `UPDATE runners SET last_seen = ?, version = CASE WHEN ? = '' THEN version ELSE ? END WHERE id = ?`, now(), version, version, id)
	return err
}

// SetRunnerDraining slaat de lokale pauze van de runner op (uit de heartbeat).
func (s *Store) SetRunnerDraining(ctx context.Context, id int64, draining bool) error {
	v := 0
	if draining {
		v = 1
	}
	_, err := s.db.ExecContext(ctx, `UPDATE runners SET draining = ? WHERE id = ?`, v, id)
	return err
}

// ListRunners geeft de niet-ingetrokken runners van een eigenaar.
func (s *Store) ListRunners(ctx context.Context, ownerKind string, ownerID int64) ([]Runner, error) {
	rows, err := s.db.QueryContext(ctx, `SELECT `+runnerCols+` FROM runners WHERE owner_kind = ? AND owner_id = ? AND revoked = 0 ORDER BY id`, ownerKind, ownerID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []Runner
	for rows.Next() {
		r, err := scanRunner(rows)
		if err != nil {
			return nil, err
		}
		out = append(out, r)
	}
	return out, rows.Err()
}

// RevokeRunner trekt een runner in; zijn token werkt daarna niet meer.
func (s *Store) RevokeRunner(ctx context.Context, ownerKind string, ownerID, id int64) error {
	res, err := s.db.ExecContext(ctx, `UPDATE runners SET revoked = 1 WHERE id = ? AND owner_kind = ? AND owner_id = ?`, id, ownerKind, ownerID)
	if err != nil {
		return err
	}
	if n, _ := res.RowsAffected(); n == 0 {
		return errNotFound
	}
	return nil
}

// UserRunnerPref is own_first of builtin_first.
func (s *Store) UserRunnerPref(ctx context.Context, userID int64) string {
	var p string
	if err := s.db.QueryRowContext(ctx, `SELECT runner_pref FROM users WHERE id = ?`, userID).Scan(&p); err != nil || p != RunnerPrefOwnFirst {
		return RunnerPrefBuiltinFirst
	}
	return p
}

// SetUserRunnerPref bewaart de voorkeur.
func (s *Store) SetUserRunnerPref(ctx context.Context, userID int64, pref string) error {
	if pref != RunnerPrefOwnFirst {
		pref = RunnerPrefBuiltinFirst
	}
	_, err := s.db.ExecContext(ctx, `UPDATE users SET runner_pref = ? WHERE id = ?`, pref, userID)
	return err
}

// GroupBuiltinFirst: "Probeer BlueGit runner eerst".
func (s *Store) GroupBuiltinFirst(ctx context.Context, groupID int64) bool {
	var v int
	_ = s.db.QueryRowContext(ctx, `SELECT builtin_first FROM groups WHERE id = ?`, groupID).Scan(&v)
	return v == 1
}

// SetGroupBuiltinFirst zet de groepsinstelling.
func (s *Store) SetGroupBuiltinFirst(ctx context.Context, groupID int64, on bool) error {
	v := 0
	if on {
		v = 1
	}
	_, err := s.db.ExecContext(ctx, `UPDATE groups SET builtin_first = ? WHERE id = ?`, v, groupID)
	return err
}

// SetRunnerOptIn: maintainer userID staat zijn account-runners toe voor de groep.
func (s *Store) SetRunnerOptIn(ctx context.Context, groupID, userID int64, on bool) error {
	if on {
		_, err := s.db.ExecContext(ctx, `INSERT OR IGNORE INTO group_runner_optin (group_id, user_id) VALUES (?, ?)`, groupID, userID)
		return err
	}
	_, err := s.db.ExecContext(ctx, `DELETE FROM group_runner_optin WHERE group_id = ? AND user_id = ?`, groupID, userID)
	return err
}

// RunnerOptIns zijn de gebruikers die hun runners voor de groep toestaan.
func (s *Store) RunnerOptIns(ctx context.Context, groupID int64) ([]int64, error) {
	rows, err := s.db.QueryContext(ctx, `SELECT user_id FROM group_runner_optin WHERE group_id = ? ORDER BY user_id`, groupID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []int64
	for rows.Next() {
		var id int64
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		out = append(out, id)
	}
	return out, rows.Err()
}

// JobRun is de runner-administratie van één job.
type JobRun struct {
	RunnerID   int64
	RunnerName string
	OfferTier  int
	OfferAt    time.Time
}

// JobRun leest de administratie; een lege JobRun als er niets is.
func (s *Store) JobRun(ctx context.Context, jobID int64) JobRun {
	var jr JobRun
	var at string
	if err := s.db.QueryRowContext(ctx, `SELECT runner_id, runner_name, offer_tier, offer_at FROM job_runs WHERE job_id = ?`, jobID).Scan(&jr.RunnerID, &jr.RunnerName, &jr.OfferTier, &at); err != nil {
		return JobRun{}
	}
	jr.OfferAt = parseTime(at)
	return jr
}

// SetJobOffer zet de huidige trede in de runnervolgorde.
func (s *Store) SetJobOffer(ctx context.Context, jobID int64, tier int, at time.Time) error {
	_, err := s.db.ExecContext(ctx, `INSERT INTO job_runs (job_id, offer_tier, offer_at) VALUES (?, ?, ?)
		ON CONFLICT(job_id) DO UPDATE SET offer_tier = excluded.offer_tier, offer_at = excluded.offer_at`, jobID, tier, at.UTC().Format(time.RFC3339Nano))
	return err
}

// ClearJobOffer haalt het aanbod weg (bijvoorbeeld bij een retry).
func (s *Store) ClearJobOffer(ctx context.Context, jobID int64) error {
	_, err := s.db.ExecContext(ctx, `UPDATE job_runs SET offer_at = '', offer_tier = 0 WHERE job_id = ?`, jobID)
	return err
}

// SetJobRunner noteert wie de job draait.
func (s *Store) SetJobRunner(ctx context.Context, jobID, runnerID int64, name string) error {
	_, err := s.db.ExecContext(ctx, `INSERT INTO job_runs (job_id, runner_id, runner_name) VALUES (?, ?, ?)
		ON CONFLICT(job_id) DO UPDATE SET runner_id = excluded.runner_id, runner_name = excluded.runner_name`, jobID, runnerID, name)
	return err
}

// OfferedJobs zijn wachtende jobs met een actief aanbod.
func (s *Store) OfferedJobs(ctx context.Context) ([]Job, map[int64]JobRun, error) {
	rows, err := s.db.QueryContext(ctx, jobSelect+` JOIN job_runs r ON r.job_id = j.id WHERE j.status = 'queued' AND r.offer_at != '' ORDER BY j.id`)
	if err != nil {
		return nil, nil, err
	}
	var out []Job
	for rows.Next() {
		j, err := scanJob(rows)
		if err != nil {
			rows.Close()
			return nil, nil, err
		}
		out = append(out, j)
	}
	rows.Close()
	runs := map[int64]JobRun{}
	for _, j := range out {
		runs[j.ID] = s.JobRun(ctx, j.ID)
	}
	return out, runs, nil
}

// ClaimJob zet een wachtende job op running voor een runner. false als
// iemand anders hem al had.
func (s *Store) ClaimJob(ctx context.Context, jobID, runnerID int64, name string) (bool, error) {
	ok, err := s.MarkJobRunning(ctx, jobID)
	if err != nil || !ok {
		return false, err
	}
	if err := s.SetJobRunner(ctx, jobID, runnerID, name); err != nil {
		return true, err
	}
	_, err = s.db.ExecContext(ctx, `UPDATE job_runs SET offer_at = '' WHERE job_id = ?`, jobID)
	return true, err
}

// RemoteJob is een lopende job op een aparte runner.
type RemoteJob struct {
	Job      Job
	RunnerID int64
}

// RemoteRunningJobs geeft lopende jobs die een aparte runner heeft.
func (s *Store) RemoteRunningJobs(ctx context.Context) ([]RemoteJob, error) {
	rows, err := s.db.QueryContext(ctx, jobSelect+` JOIN job_runs r ON r.job_id = j.id WHERE j.status = 'running' AND r.runner_id > 0 ORDER BY j.id`)
	if err != nil {
		return nil, err
	}
	var out []RemoteJob
	for rows.Next() {
		j, err := scanJob(rows)
		if err != nil {
			rows.Close()
			return nil, err
		}
		out = append(out, RemoteJob{Job: j})
	}
	rows.Close()
	for i := range out {
		out[i].RunnerID = s.JobRun(ctx, out[i].Job.ID).RunnerID
	}
	return out, nil
}

// JobForRunner geeft een job als die bij runnerID hoort (en loopt of net klaar is).
func (s *Store) JobForRunner(ctx context.Context, runnerID, jobID int64) (Job, error) {
	if s.JobRun(ctx, jobID).RunnerID != runnerID || runnerID == 0 {
		return Job{}, errNotFound
	}
	rows, err := s.db.QueryContext(ctx, jobSelect+` WHERE j.id = ?`, jobID)
	if err != nil {
		return Job{}, err
	}
	defer rows.Close()
	if !rows.Next() {
		return Job{}, errNotFound
	}
	return scanJob(rows)
}

// RunnerRunsRepo zegt of de runner nu een job van de repo draait.
func (s *Store) RunnerRunsRepo(ctx context.Context, runnerID, repoID int64) bool {
	var n int
	_ = s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM jobs j JOIN job_runs r ON r.job_id = j.id WHERE r.runner_id = ? AND j.repo_id = ? AND j.status = 'running'`, runnerID, repoID).Scan(&n)
	return n > 0 && runnerID > 0
}

// UpdateRunner hernoemt en/of pauzeert een runner van deze eigenaar.
func (s *Store) UpdateRunner(ctx context.Context, ownerKind string, ownerID, id int64, name *string, paused *bool) (Runner, error) {
	r, err := s.RunnerByID(ctx, id)
	if err != nil || r.Revoked || r.OwnerKind != ownerKind || r.OwnerID != ownerID {
		return Runner{}, errNotFound
	}
	if name != nil {
		n := strings.TrimSpace(*name)
		if n == "" || len(n) > 80 {
			return Runner{}, errors.New("runner name must be 1-80 characters")
		}
		if _, err := s.db.ExecContext(ctx, `UPDATE runners SET name = ? WHERE id = ?`, n, id); err != nil {
			return Runner{}, err
		}
	}
	if paused != nil {
		v := 0
		if *paused {
			v = 1
		}
		if _, err := s.db.ExecContext(ctx, `UPDATE runners SET paused = ? WHERE id = ?`, v, id); err != nil {
			return Runner{}, err
		}
	}
	return s.RunnerByID(ctx, id)
}

// RunnerJob is een recente job van een runner.
type RunnerJob struct {
	JobID      int64
	PipelineID int64
	RepoID     int64
	Name       string
	Status     string
	StartedAt  time.Time
	FinishedAt time.Time
}

// RunnerJobs geeft de recentste jobs van een runner.
func (s *Store) RunnerJobs(ctx context.Context, runnerID int64, limit int) ([]RunnerJob, error) {
	if limit <= 0 || limit > 100 {
		limit = 20
	}
	rows, err := s.db.QueryContext(ctx, `SELECT j.id, j.pipeline_id, j.repo_id, j.name, j.status, COALESCE(j.started_at, ''), COALESCE(j.finished_at, '')
		FROM job_runs r JOIN jobs j ON j.id = r.job_id WHERE r.runner_id = ? ORDER BY j.id DESC LIMIT ?`, runnerID, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []RunnerJob
	for rows.Next() {
		var j RunnerJob
		var st, fin string
		if err := rows.Scan(&j.JobID, &j.PipelineID, &j.RepoID, &j.Name, &j.Status, &st, &fin); err != nil {
			return nil, err
		}
		j.StartedAt, j.FinishedAt = parseTime(st), parseTime(fin)
		out = append(out, j)
	}
	return out, rows.Err()
}
