// Package ci leest blue-ci-cd.yml en bepaalt welke jobs draaien.
// De vorm ligt dicht bij GitLab CI: stages, jobs, needs, rules, artifacts.
package ci

import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
	"time"

	"gopkg.in/yaml.v3"
)

// Pipeline is een geparset configuratiebestand.
type Pipeline struct {
	Stages    []string
	Variables map[string]string
	Image     string
	Jobs      []Job
}

// Job is één containerstap.
type Job struct {
	Name         string
	Stage        string
	Image        string
	Script       []string
	Needs        []string
	NeedsSet     bool
	Variables    map[string]string
	Artifacts    Artifacts
	Rules        []Rule
	AllowFailure bool
}

// Artifacts zijn paden die na een geslaagde job bewaard blijven.
type Artifacts struct {
	Paths    []string
	ExpireIn time.Duration
}

// Rule is één voorwaarde. De job draait als minstens één rule klopt.
// Zonder rules draait de job altijd.
type Rule struct {
	If string
}

// Parse leest YAML. Jobvolgorde blijft de volgorde uit het bestand.
func Parse(data []byte) (Pipeline, error) {
	var root yaml.Node
	if err := yaml.Unmarshal(data, &root); err != nil {
		return Pipeline{}, fmt.Errorf("yaml: %w", err)
	}
	if root.Kind != yaml.DocumentNode || len(root.Content) != 1 || root.Content[0].Kind != yaml.MappingNode {
		return Pipeline{}, fmt.Errorf("blue-ci-cd.yml moet een mapping zijn")
	}
	body := root.Content[0]
	var p Pipeline
	p.Variables = map[string]string{}
	for i := 0; i < len(body.Content); i += 2 {
		key := body.Content[i].Value
		val := body.Content[i+1]
		switch key {
		case "stages":
			stages, err := scalarList(val)
			if err != nil {
				return Pipeline{}, fmt.Errorf("stages: %w", err)
			}
			p.Stages = stages
		case "variables":
			vars, err := scalarMap(val)
			if err != nil {
				return Pipeline{}, fmt.Errorf("variables: %w", err)
			}
			p.Variables = vars
		case "image":
			if val.Kind != yaml.ScalarNode {
				return Pipeline{}, fmt.Errorf("image moet een tekst zijn")
			}
			p.Image = val.Value
		case "jobs":
			jobs, err := parseJobs(val)
			if err != nil {
				return Pipeline{}, err
			}
			p.Jobs = jobs
		default:
			return Pipeline{}, fmt.Errorf("onbekend veld %q", key)
		}
	}
	if err := p.validate(); err != nil {
		return Pipeline{}, err
	}
	return p, nil
}

func parseJobs(node *yaml.Node) ([]Job, error) {
	if node.Kind != yaml.MappingNode {
		return nil, fmt.Errorf("jobs moet een mapping zijn")
	}
	var jobs []Job
	for i := 0; i < len(node.Content); i += 2 {
		name := node.Content[i].Value
		body := node.Content[i+1]
		job, err := parseJob(name, body)
		if err != nil {
			return nil, fmt.Errorf("job %s: %w", name, err)
		}
		jobs = append(jobs, job)
	}
	return jobs, nil
}

func parseJob(name string, node *yaml.Node) (Job, error) {
	if node.Kind != yaml.MappingNode {
		return Job{}, fmt.Errorf("moet een mapping zijn")
	}
	j := Job{Name: name, Variables: map[string]string{}}
	for i := 0; i < len(node.Content); i += 2 {
		key := node.Content[i].Value
		val := node.Content[i+1]
		switch key {
		case "stage":
			if val.Kind != yaml.ScalarNode {
				return Job{}, fmt.Errorf("stage moet tekst zijn")
			}
			j.Stage = val.Value
		case "image":
			if val.Kind != yaml.ScalarNode {
				return Job{}, fmt.Errorf("image moet tekst zijn")
			}
			j.Image = val.Value
		case "script":
			lines, err := scalarList(val)
			if err != nil {
				return Job{}, fmt.Errorf("script: %w", err)
			}
			j.Script = lines
		case "needs":
			needs, err := scalarList(val)
			if err != nil {
				return Job{}, fmt.Errorf("needs: %w", err)
			}
			j.Needs = needs
			j.NeedsSet = true
		case "variables":
			vars, err := scalarMap(val)
			if err != nil {
				return Job{}, fmt.Errorf("variables: %w", err)
			}
			j.Variables = vars
		case "artifacts":
			art, err := parseArtifacts(val)
			if err != nil {
				return Job{}, err
			}
			j.Artifacts = art
		case "rules":
			rules, err := parseRules(val)
			if err != nil {
				return Job{}, err
			}
			j.Rules = rules
		case "allow_failure":
			b, err := parseBool(val)
			if err != nil {
				return Job{}, fmt.Errorf("allow_failure: %w", err)
			}
			j.AllowFailure = b
		default:
			return Job{}, fmt.Errorf("onbekend veld %q", key)
		}
	}
	return j, nil
}

func parseArtifacts(node *yaml.Node) (Artifacts, error) {
	if node.Kind != yaml.MappingNode {
		return Artifacts{}, fmt.Errorf("artifacts moet een mapping zijn")
	}
	var a Artifacts
	for i := 0; i < len(node.Content); i += 2 {
		key := node.Content[i].Value
		val := node.Content[i+1]
		switch key {
		case "paths":
			paths, err := scalarList(val)
			if err != nil {
				return Artifacts{}, fmt.Errorf("artifacts.paths: %w", err)
			}
			a.Paths = paths
		case "expire_in":
			if val.Kind != yaml.ScalarNode {
				return Artifacts{}, fmt.Errorf("expire_in moet tekst zijn")
			}
			d, err := parseExpire(val.Value)
			if err != nil {
				return Artifacts{}, err
			}
			a.ExpireIn = d
		default:
			return Artifacts{}, fmt.Errorf("onbekend artifacts-veld %q", key)
		}
	}
	return a, nil
}

func parseRules(node *yaml.Node) ([]Rule, error) {
	if node.Kind != yaml.SequenceNode {
		return nil, fmt.Errorf("rules moet een lijst zijn")
	}
	var rules []Rule
	for _, item := range node.Content {
		if item.Kind != yaml.MappingNode {
			return nil, fmt.Errorf("rule moet een mapping zijn")
		}
		var r Rule
		for i := 0; i < len(item.Content); i += 2 {
			key := item.Content[i].Value
			val := item.Content[i+1]
			if key != "if" {
				return nil, fmt.Errorf("rule ondersteunt alleen if, kreeg %q", key)
			}
			if val.Kind != yaml.ScalarNode || strings.TrimSpace(val.Value) == "" {
				return nil, fmt.Errorf("rule.if moet tekst zijn")
			}
			r.If = strings.TrimSpace(val.Value)
		}
		if r.If == "" {
			return nil, fmt.Errorf("rule mist if")
		}
		if _, err := compileRule(r.If); err != nil {
			return nil, err
		}
		rules = append(rules, r)
	}
	return rules, nil
}

func (p *Pipeline) validate() error {
	if len(p.Jobs) == 0 {
		return fmt.Errorf("geen jobs")
	}
	seenStage := map[string]bool{}
	for _, s := range p.Stages {
		if s == "" {
			return fmt.Errorf("lege stage-naam")
		}
		if seenStage[s] {
			return fmt.Errorf("dubbele stage %q", s)
		}
		seenStage[s] = true
	}
	if len(p.Stages) == 0 {
		var order []string
		have := map[string]bool{}
		for i := range p.Jobs {
			if p.Jobs[i].Stage == "" {
				p.Jobs[i].Stage = "test"
			}
			if !have[p.Jobs[i].Stage] {
				have[p.Jobs[i].Stage] = true
				order = append(order, p.Jobs[i].Stage)
			}
		}
		p.Stages = order
		for _, s := range p.Stages {
			seenStage[s] = true
		}
	}
	names := map[string]bool{}
	for i := range p.Jobs {
		j := &p.Jobs[i]
		if j.Name == "" || strings.ContainsAny(j.Name, " \t\n/\\") {
			return fmt.Errorf("ongeldige jobnaam %q", j.Name)
		}
		if names[j.Name] {
			return fmt.Errorf("dubbele job %q", j.Name)
		}
		names[j.Name] = true
		if j.Stage == "" {
			return fmt.Errorf("job %s mist stage", j.Name)
		}
		if !seenStage[j.Stage] {
			return fmt.Errorf("job %s gebruikt onbekende stage %q", j.Name, j.Stage)
		}
		if j.Image == "" {
			j.Image = p.Image
		}
		if strings.TrimSpace(j.Image) == "" || strings.ContainsAny(j.Image, " \t\n") {
			return fmt.Errorf("job %s mist een image", j.Name)
		}
		if len(j.Script) == 0 {
			return fmt.Errorf("job %s mist script", j.Name)
		}
		for _, line := range j.Script {
			if strings.TrimSpace(line) == "" {
				return fmt.Errorf("job %s heeft een lege scriptregel", j.Name)
			}
		}
		for _, path := range j.Artifacts.Paths {
			if err := safeRelPath(path); err != nil {
				return fmt.Errorf("job %s artifact: %w", j.Name, err)
			}
		}
	}
	for _, j := range p.Jobs {
		for _, need := range j.Needs {
			if !names[need] {
				return fmt.Errorf("job %s needs onbekende job %q", j.Name, need)
			}
			if need == j.Name {
				return fmt.Errorf("job %s kan niet van zichzelf afhangen", j.Name)
			}
		}
	}
	if err := detectCycles(p.Jobs); err != nil {
		return err
	}
	return nil
}

func detectCycles(jobs []Job) error {
	idx := map[string]int{}
	for i, j := range jobs {
		idx[j.Name] = i
	}
	const (
		white = 0
		gray  = 1
		black = 2
	)
	color := make([]int, len(jobs))
	var visit func(int) error
	visit = func(i int) error {
		if color[i] == gray {
			return fmt.Errorf("cyclus in needs bij job %s", jobs[i].Name)
		}
		if color[i] == black {
			return nil
		}
		color[i] = gray
		for _, n := range jobs[i].Needs {
			if err := visit(idx[n]); err != nil {
				return err
			}
		}
		color[i] = black
		return nil
	}
	for i := range jobs {
		if err := visit(i); err != nil {
			return err
		}
	}
	return nil
}

// ActiveJobs filtert jobs waarvan de rules niet kloppen.
func (p Pipeline) ActiveJobs(env map[string]string) ([]Job, error) {
	var out []Job
	for _, j := range p.Jobs {
		ok, err := j.matches(env)
		if err != nil {
			return nil, fmt.Errorf("job %s: %w", j.Name, err)
		}
		if ok {
			out = append(out, j)
		}
	}
	return out, nil
}

func (j Job) matches(env map[string]string) (bool, error) {
	if len(j.Rules) == 0 {
		return true, nil
	}
	for _, r := range j.Rules {
		ok, err := evalRule(r.If, env)
		if err != nil {
			return false, err
		}
		if ok {
			return true, nil
		}
	}
	return false, nil
}

// Gate beslist of een job mag starten.
// "ready" betekent dat alle voorgangers klaar zijn.
// "wait" betekent dat er nog een voorganger loopt of in de wachtrij staat.
// "skip" betekent dat een voorganger mislukte zonder allow_failure.
//
// NeedsSet volgt de genoemde jobs, ook als de lijst leeg is.
// Zonder needs wacht de job op alle jobs in eerdere stages.
func Gate(jobs []Job, status map[string]string, job Job) string {
	byName := map[string]Job{}
	for _, j := range jobs {
		byName[j.Name] = j
	}
	var deps []Job
	if job.NeedsSet {
		for _, n := range job.Needs {
			deps = append(deps, byName[n])
		}
	} else {
		stagePos := map[string]int{}
		order := 0
		for _, j := range jobs {
			if _, ok := stagePos[j.Stage]; !ok {
				stagePos[j.Stage] = order
				order++
			}
		}
		my := stagePos[job.Stage]
		for _, j := range jobs {
			if stagePos[j.Stage] < my {
				deps = append(deps, j)
			}
		}
	}
	for _, d := range deps {
		switch status[d.Name] {
		case "success", "skipped":
			continue
		case "failed":
			if d.AllowFailure {
				continue
			}
			return "skip"
		default:
			return "wait"
		}
	}
	return "ready"
}

var (
	reEq = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*==\s*"([^"]*)"$`)
	reNe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*!=\s*"([^"]*)"$`)
	reRe = regexp.MustCompile(`^\$([A-Za-z_][A-Za-z0-9_]*)\s*=~\s*/(.+)/$`)
)

type compiledRule struct {
	kind string
	name string
	arg  string
	re   *regexp.Regexp
}

func compileRule(expr string) (compiledRule, error) {
	if m := reEq.FindStringSubmatch(expr); m != nil {
		return compiledRule{kind: "eq", name: m[1], arg: m[2]}, nil
	}
	if m := reNe.FindStringSubmatch(expr); m != nil {
		return compiledRule{kind: "ne", name: m[1], arg: m[2]}, nil
	}
	if m := reRe.FindStringSubmatch(expr); m != nil {
		re, err := regexp.Compile(m[2])
		if err != nil {
			return compiledRule{}, fmt.Errorf("ongeldige regex in rule %q: %w", expr, err)
		}
		return compiledRule{kind: "re", name: m[1], re: re}, nil
	}
	return compiledRule{}, fmt.Errorf("rule %q wordt niet begrepen", expr)
}

func evalRule(expr string, env map[string]string) (bool, error) {
	c, err := compileRule(expr)
	if err != nil {
		return false, err
	}
	val := env[c.name]
	switch c.kind {
	case "eq":
		return val == c.arg, nil
	case "ne":
		return val != c.arg, nil
	case "re":
		return c.re.MatchString(val), nil
	default:
		return false, fmt.Errorf("interne rulefout")
	}
}

func parseExpire(s string) (time.Duration, error) {
	s = strings.TrimSpace(s)
	if s == "" || s == "never" {
		return 0, nil
	}
	if len(s) < 2 {
		return 0, fmt.Errorf("expire_in %q is ongeldig", s)
	}
	n, err := strconv.Atoi(s[:len(s)-1])
	if err != nil || n < 0 {
		return 0, fmt.Errorf("expire_in %q is ongeldig", s)
	}
	switch s[len(s)-1] {
	case 'm':
		return time.Duration(n) * time.Minute, nil
	case 'h':
		return time.Duration(n) * time.Hour, nil
	case 'd':
		return time.Duration(n) * 24 * time.Hour, nil
	case 'w':
		return time.Duration(n) * 7 * 24 * time.Hour, nil
	default:
		return 0, fmt.Errorf("expire_in %q is ongeldig", s)
	}
}

func scalarList(node *yaml.Node) ([]string, error) {
	if node.Kind != yaml.SequenceNode {
		return nil, fmt.Errorf("verwacht een lijst")
	}
	var out []string
	for _, item := range node.Content {
		if item.Kind != yaml.ScalarNode {
			return nil, fmt.Errorf("lijst mag alleen tekst bevatten")
		}
		out = append(out, item.Value)
	}
	return out, nil
}

func scalarMap(node *yaml.Node) (map[string]string, error) {
	if node.Kind != yaml.MappingNode {
		return nil, fmt.Errorf("verwacht een mapping")
	}
	out := map[string]string{}
	for i := 0; i < len(node.Content); i += 2 {
		k := node.Content[i]
		v := node.Content[i+1]
		if k.Kind != yaml.ScalarNode || v.Kind != yaml.ScalarNode {
			return nil, fmt.Errorf("variabelen moeten tekst zijn")
		}
		out[k.Value] = v.Value
	}
	return out, nil
}

func parseBool(node *yaml.Node) (bool, error) {
	if node.Kind != yaml.ScalarNode {
		return false, fmt.Errorf("verwacht ja of nee")
	}
	switch strings.ToLower(node.Value) {
	case "true", "yes", "ja":
		return true, nil
	case "false", "no", "nee":
		return false, nil
	default:
		return false, fmt.Errorf("verwacht true of false")
	}
}

func safeRelPath(p string) error {
	if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, "\\") {
		return fmt.Errorf("pad %q moet relatief zijn", p)
	}
	for _, part := range strings.Split(p, "/") {
		if part == ".." {
			return fmt.Errorf("pad %q mag niet buiten de workspace", p)
		}
	}
	return nil
}
