package store

import "context"

// ClonePipeline maakt een nieuwe pipeline op dezelfde commit, ref, bron
// en merge-requestkoppeling. De jobs beginnen opnieuw. Een geslaagde
// job van de oude pipeline blijft daar staan.
func (s *Store) ClonePipeline(ctx context.Context, repoID, id int64) (int64, error) {
	p, err := s.PipelineByID(ctx, repoID, id)
	if err != nil {
		return 0, err
	}
	jobs, err := s.JobsByPipeline(ctx, id)
	if err != nil {
		return 0, err
	}
	tx, err := s.db.BeginTx(ctx, nil)
	if err != nil {
		return 0, err
	}
	defer func() { _ = tx.Rollback() }()
	res, err := tx.ExecContext(ctx, `INSERT INTO pipelines (repo_id, commit_sha, ref, status, source, actor, commit_title, created_at, mr_id, target_sha)
		VALUES (?, ?, ?, 'queued', ?, ?, ?, ?, ?, ?)`,
		p.RepoID, p.CommitSHA, p.Ref, p.Source, p.Actor, p.CommitTitle, now(), p.MRID, p.TargetSHA)
	if err != nil {
		return 0, err
	}
	newID, _ := res.LastInsertId()
	if err := insertPipelineJobs(ctx, tx, newID, p.RepoID, jobsToNew(jobs)); err != nil {
		return 0, err
	}
	if err := tx.Commit(); err != nil {
		return 0, err
	}
	return newID, nil
}

// RetryFailedJobs zet mislukte jobs terug in de wachtrij, plus de jobs
// die daardoor niets deden: overgeslagen of nooit gestarte jobs die via
// needs of een latere stage van een mislukte job afhangen.
// Geslaagde jobs blijven. false betekent dat er geen mislukte job is.
func (s *Store) RetryFailedJobs(ctx context.Context, pipelineID int64) (bool, error) {
	jobs, err := s.JobsByPipeline(ctx, pipelineID)
	if err != nil {
		return false, err
	}
	plan := retryPlan(jobs)
	if plan == nil {
		return false, nil
	}
	tx, err := s.db.BeginTx(ctx, nil)
	if err != nil {
		return false, err
	}
	defer func() { _ = tx.Rollback() }()
	for id, status := range plan {
		if _, err := tx.ExecContext(ctx, `UPDATE jobs SET status = ?, log = '', attempt = 0, finished_at = NULL, started_at = NULL WHERE id = ? AND pipeline_id = ?`, status, id, pipelineID); err != nil {
			return false, err
		}
	}
	if err := tx.Commit(); err != nil {
		return false, err
	}
	if _, err := s.RefreshPipelineStatus(ctx, pipelineID); err != nil {
		return false, err
	}
	return true, nil
}

func jobsToNew(jobs []Job) []NewJob {
	out := make([]NewJob, len(jobs))
	for i, j := range jobs {
		out[i] = NewJob{
			Name: j.Name, Stage: j.Stage, Position: j.Position,
			Image: j.Image, Before: j.Before, Script: j.Script, After: j.After,
			Needs: j.Needs, Optional: j.Optional, NeedsSet: j.NeedsSet,
			Variables: j.Variables, ArtifactPaths: j.ArtifactPaths, ArtifactExpire: j.ArtifactExpire,
			AllowFailure: j.AllowFailure, When: j.When, Timeout: j.Timeout,
			Tags: j.Tags, CachePaths: j.CachePaths, CacheKey: j.CacheKey,
			ResourceGroup: j.ResourceGroup, RetryMax: j.RetryMax, RetryWhen: j.RetryWhen,
			Services: j.Services, Environment: j.Environment, EnvironmentURL: j.EnvironmentURL,
			Interruptible: j.Interruptible, DoNotInterrupt: j.DoNotInterrupt,
		}
	}
	return out
}

// retryPlan kiest per job de nieuwe status.
// nil betekent dat geen enkele job de status failed heeft.
func retryPlan(jobs []Job) map[int64]string {
	failed := map[int]bool{}
	hasFailed := false
	for i, j := range jobs {
		if j.Status == "failed" {
			failed[i] = true
			hasFailed = true
		}
	}
	if !hasFailed {
		return nil
	}
	preds := predecessorIndexes(jobs)
	down := map[int]bool{}
	for {
		moved := false
		for i, j := range jobs {
			if failed[i] || down[i] || !jobIdle(j.Status) {
				continue
			}
			for _, p := range preds[i] {
				if failed[p] || down[p] {
					down[i] = true
					moved = true
					break
				}
			}
		}
		if !moved {
			break
		}
	}
	out := make(map[int64]string, len(failed)+len(down))
	for i, j := range jobs {
		switch {
		case failed[i]:
			out[j.ID] = "queued"
		case down[i]:
			if j.When == "manual" {
				out[j.ID] = "manual"
			} else {
				out[j.ID] = "queued"
			}
		}
	}
	return out
}

// jobIdle is een job die nog niet gedraaid heeft of is overgeslagen.
func jobIdle(status string) bool {
	switch status {
	case "skipped", "created", "pending", "queued", "manual", "":
		return true
	default:
		return false
	}
}

// predecessorIndexes volgt needs als die gezet zijn, ook bij een lege lijst.
// Zonder needs zijn alle jobs in eerdere stages de voorgangers.
func predecessorIndexes(jobs []Job) [][]int {
	byName := map[string][]int{}
	stagePos := map[string]int{}
	order := 0
	for i, j := range jobs {
		byName[j.Name] = append(byName[j.Name], i)
		if _, ok := stagePos[j.Stage]; !ok {
			stagePos[j.Stage] = order
			order++
		}
	}
	out := make([][]int, len(jobs))
	for i, j := range jobs {
		if j.NeedsSet {
			for _, n := range j.Needs {
				out[i] = append(out[i], byName[n]...)
			}
			continue
		}
		my := stagePos[j.Stage]
		for k, other := range jobs {
			if k != i && stagePos[other.Stage] < my {
				out[i] = append(out[i], k)
			}
		}
	}
	return out
}
