package store

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

// Verlopen handmatige jobs (stale manual).
//
// Een handmatige job (status manual) verloopt als zijn pipeline stale is:
//   - superseded: er is een nieuwere pipeline op dezelfde ref (en hetzelfde
//     merge request) in dezelfde repository. Een pipeline die alleen een
//     kapotte blue-ci-cd.yml meldt, telt niet als nieuwere pipeline.
//   - leeftijd: de pipeline wacht alleen nog op handmatige jobs (status
//     manual) en is ouder dan N dagen. N is een instance-instelling
//     (standaard 7) die per repository overschreven kan worden; 0 = uit.
//
// Verlopen is niet destructief: de job gaat naar canceled met een reden en een
// logregel; logs en artifacts blijven staan. Jobs die alleen nog op de
// verlopen job wachtten (needs), verlopen mee. Niet-handmatige jobs die nog
// lopen of in de wachtrij staan, blijven ongemoeid.

// DefaultStaleManualDays is de standaard voor de leeftijdsregel.
const DefaultStaleManualDays = 7

const staleManualKey = "stale_manual_days"

// StaleManualDays geeft de instance-instelling (dagen, 0 = uit).
func (s *Store) StaleManualDays(ctx context.Context) (int, error) {
	var v string
	err := s.db.QueryRowContext(ctx, `SELECT value FROM instance_settings WHERE key = ?`, staleManualKey).Scan(&v)
	if errors.Is(err, sql.ErrNoRows) {
		return DefaultStaleManualDays, nil
	}
	if err != nil {
		return 0, err
	}
	n, err := strconv.Atoi(v)
	if err != nil || n < 0 {
		return DefaultStaleManualDays, nil
	}
	return n, nil
}

// SetStaleManualDays zet de instance-instelling (0 = uit, max 3650).
func (s *Store) SetStaleManualDays(ctx context.Context, days int) error {
	if days < 0 || days > 3650 {
		return errors.New("stale manual days out of range")
	}
	_, err := s.db.ExecContext(ctx, `INSERT INTO instance_settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`, staleManualKey, strconv.Itoa(days))
	return err
}

// RepoStaleManualDays geeft de eigen instelling van een repository;
// -1 = de instance-instelling volgen.
func (s *Store) RepoStaleManualDays(ctx context.Context, repoID int64) (int, error) {
	var n int
	err := s.db.QueryRowContext(ctx, `SELECT stale_manual_days FROM repos WHERE id = ?`, repoID).Scan(&n)
	return n, err
}

// SetRepoStaleManualDays zet de eigen instelling (-1 = volgen, 0 = uit).
func (s *Store) SetRepoStaleManualDays(ctx context.Context, repoID int64, days int) error {
	if days < -1 || days > 3650 {
		return errors.New("stale manual days out of range")
	}
	_, err := s.db.ExecContext(ctx, `UPDATE repos SET stale_manual_days = ? WHERE id = ?`, days, repoID)
	return err
}

// ExpiredManual is één pipeline waarvan handmatige jobs verlopen zijn.
type ExpiredManual struct {
	RepoID     int64
	PipelineID int64
	Ref        string
	Jobs       int
	Reason     string // superseded of stale
}

// expirePipelineManual laat de handmatige jobs van één pipeline verlopen
// (en de jobs die alleen daarop wachten) en werkt de pipelinestatus bij.
func (s *Store) expirePipelineManual(ctx context.Context, pipelineID int64, reason, note string) (int, error) {
	jobs, err := s.JobsByPipeline(ctx, pipelineID)
	if err != nil {
		return 0, err
	}
	blocked := manualBlocked(jobs)
	line := time.Now().UTC().Format(time.RFC3339) + "\t" + note + "\n"
	n := 0
	for i, j := range jobs {
		if j.Status != "manual" && !(j.Status == "queued" && blocked[i]) {
			continue
		}
		res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'canceled', failure_reason = ?, log = log || ?, finished_at = ? WHERE id = ? AND status = ?`, reason, line, now(), j.ID, j.Status)
		if err != nil {
			return n, err
		}
		if c, _ := res.RowsAffected(); c == 1 {
			n++
		}
	}
	if n > 0 {
		if _, err := s.RefreshPipelineStatus(ctx, pipelineID); err != nil {
			return n, err
		}
	}
	return n, nil
}

const noteSuperseded = "manual job expired (obsolete): a newer pipeline exists for the same ref"

func noteStale(days int) string {
	return "manual job expired (obsolete): the pipeline waited only for manual action for more than " + strconv.Itoa(days) + " days"
}

// configFailureSQL herkent een pipeline die alleen een kapotte config meldt.
const configFailureSQL = `EXISTS (SELECT 1 FROM jobs cj WHERE cj.pipeline_id = n.id AND cj.name = 'blue-ci-cd' AND cj.script = 'exit 1' AND cj.image = 'alpine:3.20' AND cj.position = 0)
	AND (SELECT COUNT(*) FROM jobs cj WHERE cj.pipeline_id = n.id) = 1`

// ExpireSupersededManual laat handmatige jobs verlopen in pipelines op
// dezelfde ref (en hetzelfde MR) die ouder zijn dan keep.
func (s *Store) ExpireSupersededManual(ctx context.Context, repoID int64, ref string, keep int64) ([]ExpiredManual, error) {
	rows, err := s.db.QueryContext(ctx, `SELECT DISTINCT p.id, p.ref FROM pipelines p JOIN jobs j ON j.pipeline_id = p.id
		JOIN pipelines n ON n.id = ?
		WHERE p.repo_id = ? AND p.ref = ? AND p.id < n.id AND p.mr_id = n.mr_id AND j.status = 'manual'
		AND NOT (`+configFailureSQL+`)`, keep, repoID, ref)
	if err != nil {
		return nil, err
	}
	return s.expireRows(ctx, rows, repoID, "superseded", ReasonSuperseded, noteSuperseded)
}

func (s *Store) expireRows(ctx context.Context, rows *sql.Rows, repoID int64, kind, reason, note string) ([]ExpiredManual, error) {
	type item struct {
		id  int64
		ref string
	}
	var items []item
	for rows.Next() {
		var it item
		if err := rows.Scan(&it.id, &it.ref); err != nil {
			rows.Close()
			return nil, err
		}
		items = append(items, it)
	}
	err := rows.Err()
	rows.Close()
	if err != nil {
		return nil, err
	}
	var out []ExpiredManual
	for _, it := range items {
		n, err := s.expirePipelineManual(ctx, it.id, reason, note)
		if err != nil {
			return out, err
		}
		if n > 0 {
			out = append(out, ExpiredManual{RepoID: repoID, PipelineID: it.id, Ref: it.ref, Jobs: n, Reason: kind})
		}
	}
	return out, nil
}

// SweepStaleManual loopt alle repositories langs: eerst superseded
// (voor oude pipelines van vóór deze functie), dan de leeftijdsregel.
func (s *Store) SweepStaleManual(ctx context.Context, at time.Time) ([]ExpiredManual, error) {
	def, err := s.StaleManualDays(ctx)
	if err != nil {
		return nil, err
	}
	// Superseded: pipelines met een handmatige job en een nieuwere pipeline
	// op dezelfde ref en hetzelfde MR.
	rows, err := s.db.QueryContext(ctx, `SELECT DISTINCT p.repo_id, p.id, p.ref FROM pipelines p JOIN jobs j ON j.pipeline_id = p.id
		WHERE j.status = 'manual' AND EXISTS (
			SELECT 1 FROM pipelines n WHERE n.repo_id = p.repo_id AND n.ref = p.ref AND n.mr_id = p.mr_id AND n.id > p.id
			AND NOT (`+configFailureSQL+`))
		ORDER BY p.id`)
	if err != nil {
		return nil, err
	}
	type item struct {
		repo, id int64
		ref      string
	}
	var sup []item
	for rows.Next() {
		var it item
		if err := rows.Scan(&it.repo, &it.id, &it.ref); err != nil {
			rows.Close()
			return nil, err
		}
		sup = append(sup, it)
	}
	err = rows.Err()
	rows.Close()
	if err != nil {
		return nil, err
	}
	var out []ExpiredManual
	for _, it := range sup {
		n, err := s.expirePipelineManual(ctx, it.id, ReasonSuperseded, noteSuperseded)
		if err != nil {
			return out, err
		}
		if n > 0 {
			out = append(out, ExpiredManual{RepoID: it.repo, PipelineID: it.id, Ref: it.ref, Jobs: n, Reason: "superseded"})
		}
	}
	// Leeftijd: pipelines die alleen nog op handmatige actie wachten.
	rows, err = s.db.QueryContext(ctx, `SELECT p.repo_id, p.id, p.ref, p.created_at, r.stale_manual_days FROM pipelines p JOIN repos r ON r.id = p.repo_id WHERE p.status = 'manual' ORDER BY p.id`)
	if err != nil {
		return out, err
	}
	type aged struct {
		item
		days int
	}
	var old []aged
	for rows.Next() {
		var it item
		var created string
		var days int
		if err := rows.Scan(&it.repo, &it.id, &it.ref, &created, &days); err != nil {
			rows.Close()
			return out, err
		}
		if days < 0 {
			days = def
		}
		if days == 0 {
			continue
		}
		t := parseTime(created)
		if t.IsZero() || at.Sub(t) < time.Duration(days)*24*time.Hour {
			continue
		}
		old = append(old, aged{it, days})
	}
	err = rows.Err()
	rows.Close()
	if err != nil {
		return out, err
	}
	for _, it := range old {
		n, err := s.expirePipelineManual(ctx, it.id, ReasonStaleManual, noteStale(it.days))
		if err != nil {
			return out, err
		}
		if n > 0 {
			out = append(out, ExpiredManual{RepoID: it.repo, PipelineID: it.id, Ref: it.ref, Jobs: n, Reason: "stale"})
		}
	}
	return out, nil
}
