// Package ci leest blue-ci-cd.yml en bepaalt welke jobs draaien.
// De vorm volgt GitLab CI waar dat in BlueGit past. Een oud bestand met
// een jobs:-map blijft geldig. Jobs mogen ook los op het hoogste niveau staan.
package ci

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gopkg.in/yaml.v3"
)

// Parse leest YAML. Jobvolgorde blijft de volgorde uit het bestand.
func Parse(data []byte) (Pipeline, error) {
	return ParseIn(data, nil)
}

// ParseIn leest YAML en haalt include: local via read op.
func ParseIn(data []byte, read func(string) ([]byte, error)) (Pipeline, error) {
	p, issues, err := parseBytes(data, read, nil)
	if err != nil {
		return Pipeline{}, err
	}
	for _, is := range issues {
		if !is.Warning {
			return Pipeline{}, is
		}
	}
	p.Warnings = warningsOnly(issues)
	return p, nil
}

// Lint geeft elke fout en waarschuwing, met regelnummer, zonder te stoppen bij de eerste.
func Lint(data []byte, read func(string) ([]byte, error)) (Pipeline, []Issue) {
	p, issues, err := parseBytes(data, read, nil)
	if err != nil {
		// parseBytes verpakt een YAML-fout al als ci.err.yaml. Nog eens
		// verpakken geeft "invalid YAML: invalid YAML: ...".
		line := Issue{Line: 1, Key: "ci.err.yaml", Args: []any{err.Error()}}
		var ie i18n.Error
		if errors.As(err, &ie) {
			line.Key, line.Args = ie.Key, ie.Args
		}
		issues = append([]Issue{line}, issues...)
	}
	return p, issues
}

func (i Issue) Error() string { return i18n.T(i18n.EN, i.Key, i.Args...) }

func warningsOnly(in []Issue) []Issue {
	var out []Issue
	for _, is := range in {
		if is.Warning {
			out = append(out, is)
		}
	}
	return out
}

var reserved = map[string]bool{
	"stages": true, "variables": true, "image": true, "default": true,
	"include": true, "before_script": true, "after_script": true, "cache": true,
	"workflow": true, "services": true, "spec": true, "pages": true, "jobs": true,
}

type draft struct {
	job     Job
	present map[string]bool
	extends []string
	line    int
}

func parseBytes(data []byte, read func(string) ([]byte, error), stack []string) (Pipeline, []Issue, error) {
	var root yaml.Node
	if err := yaml.Unmarshal(data, &root); err != nil {
		return Pipeline{}, nil, i18n.E("ci.err.yaml", err.Error())
	}
	// Een leeg document of alleen commentaar is een pipeline zonder jobs.
	// Een echte mapping, ook een lege zoals {}, blijft door validate gaan.
	if root.Kind == 0 || len(root.Content) == 0 {
		return Pipeline{Variables: map[string]string{}}, nil, nil
	}
	if root.Kind != yaml.DocumentNode || len(root.Content) != 1 || root.Content[0].Kind != yaml.MappingNode {
		return Pipeline{}, []Issue{{Line: 1, Key: "ci.err.mapping"}}, nil
	}
	body := root.Content[0]
	var included Pipeline
	var issues []Issue
	for i := 0; i < len(body.Content); i += 2 {
		if body.Content[i].Value != "include" {
			continue
		}
		part, more, err := parseInclude(body.Content[i+1], read, stack)
		if err != nil {
			return Pipeline{}, nil, err
		}
		issues = append(issues, more...)
		included = mergePipeline(included, part)
	}
	p := included
	if p.Variables == nil {
		p.Variables = map[string]string{}
	}
	var def draft
	def.present = map[string]bool{}
	var jobs []draft
	seenLegacy := false
	seenTop := false
	for i := 0; i < len(body.Content); i += 2 {
		keyNode := body.Content[i]
		key := keyNode.Value
		val := body.Content[i+1]
		switch key {
		case "include":
			continue
		case "stages":
			stages, iss := scalarList(val, "ci.err.list")
			issues = append(issues, iss...)
			if len(stages) > 0 {
				p.Stages = stages
			}
		case "variables":
			vars, iss := scalarMap(val)
			issues = append(issues, iss...)
			for k, v := range vars {
				p.Variables[k] = v
			}
		case "image":
			img, iss := imageOf(val)
			issues = append(issues, iss...)
			if img != "" {
				p.Image = img
			}
		case "before_script":
			lines, iss := scriptList(val)
			issues = append(issues, iss...)
			p.Before = lines
			def.present["before_script"] = true
			def.job.Before = lines
		case "after_script":
			lines, iss := scriptList(val)
			issues = append(issues, iss...)
			p.After = lines
			def.present["after_script"] = true
			def.job.After = lines
		case "cache":
			c, iss := parseCache(val)
			issues = append(issues, iss...)
			p.Cache = c
			def.present["cache"] = true
			def.job.Cache = c
		case "default":
			d, iss := parseDefault(val)
			issues = append(issues, iss...)
			def = overlayDefault(def, d)
		case "workflow":
			rules, iss := parseWorkflow(val)
			issues = append(issues, iss...)
			p.Workflow = rules
		case "services", "spec", "pages":
			issues = append(issues, Issue{Line: keyNode.Line, Key: "ci.warn.ignored", Args: []any{key}, Warning: true})
		case "jobs":
			seenLegacy = true
			parsed, iss := parseJobMap(val)
			issues = append(issues, iss...)
			jobs = append(jobs, parsed...)
		default:
			if val.Kind != yaml.MappingNode {
				issues = append(issues, Issue{Line: keyNode.Line, Key: "ci.err.unknown", Args: []any{key}})
				continue
			}
			seenTop = true
			job, iss := parseJob(key, val)
			issues = append(issues, iss...)
			jobs = append(jobs, job)
		}
	}
	if seenLegacy && seenTop {
		issues = append(issues, Issue{Line: 1, Key: "ci.err.both"})
	}
	if p.Image != "" && !def.present["image"] {
		def.present["image"] = true
		def.job.Image = p.Image
	}
	resolved, iss := applyExtends(jobs, def)
	issues = append(issues, iss...)
	byName := map[string]int{}
	var merged []Job
	for _, j := range p.Jobs {
		byName[j.Name] = len(merged)
		merged = append(merged, j)
	}
	for _, d := range resolved {
		if strings.HasPrefix(d.job.Name, ".") {
			continue
		}
		if i, ok := byName[d.job.Name]; ok {
			merged[i] = overlayJob(merged[i], d)
			continue
		}
		byName[d.job.Name] = len(merged)
		merged = append(merged, d.job)
	}
	p.Jobs = merged
	issues = append(issues, validate(&p)...)
	if hasError(issues) {
		return p, issues, nil
	}
	return p, issues, nil
}

func parseInclude(node *yaml.Node, read func(string) ([]byte, error), stack []string) (Pipeline, []Issue, error) {
	var items []*yaml.Node
	switch node.Kind {
	case yaml.SequenceNode:
		items = node.Content
	default:
		items = []*yaml.Node{node}
	}
	var out Pipeline
	var issues []Issue
	for _, item := range items {
		local, iss := includeLocal(item)
		issues = append(issues, iss...)
		if local == "" {
			continue
		}
		if read == nil {
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeRead", Args: []any{local}})
			continue
		}
		for _, prev := range stack {
			if prev == local {
				issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeCycle", Args: []any{local}})
				local = ""
				break
			}
		}
		if local == "" {
			continue
		}
		raw, err := read(local)
		if err != nil {
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.includeRead", Args: []any{local}})
			continue
		}
		part, more, err := parseBytes(raw, read, append(append([]string{}, stack...), local))
		if err != nil {
			return Pipeline{}, nil, err
		}
		issues = append(issues, more...)
		out = mergePipeline(out, part)
	}
	return out, issues, nil
}

func includeLocal(node *yaml.Node) (string, []Issue) {
	switch node.Kind {
	case yaml.ScalarNode:
		return cleanLocal(node.Value, node)
	case yaml.MappingNode:
		for i := 0; i < len(node.Content); i += 2 {
			key := node.Content[i].Value
			if key == "local" {
				if node.Content[i+1].Kind != yaml.ScalarNode {
					return "", []Issue{{Line: node.Line, Key: "ci.err.includeLocal"}}
				}
				return cleanLocal(node.Content[i+1].Value, node.Content[i+1])
			}
		}
		return "", []Issue{{Line: node.Line, Key: "ci.err.includeRemote"}}
	default:
		return "", []Issue{{Line: node.Line, Key: "ci.err.includeLocal"}}
	}
}

func cleanLocal(p string, node *yaml.Node) (string, []Issue) {
	p = strings.TrimPrefix(strings.TrimSpace(p), "/")
	if p == "" || strings.Contains(p, "\\") || strings.Contains(p, "..") {
		return "", []Issue{{Line: node.Line, Key: "ci.err.rel", Args: []any{p}}}
	}
	return p, nil
}

func mergePipeline(base, extra Pipeline) Pipeline {
	if len(extra.Stages) > 0 {
		base.Stages = extra.Stages
	}
	if base.Variables == nil {
		base.Variables = map[string]string{}
	}
	for k, v := range extra.Variables {
		base.Variables[k] = v
	}
	if extra.Image != "" {
		base.Image = extra.Image
	}
	if extra.Before != nil {
		base.Before = extra.Before
	}
	if extra.After != nil {
		base.After = extra.After
	}
	byName := map[string]int{}
	for i, j := range base.Jobs {
		byName[j.Name] = i
	}
	for _, j := range extra.Jobs {
		if i, ok := byName[j.Name]; ok {
			base.Jobs[i] = j
			continue
		}
		byName[j.Name] = len(base.Jobs)
		base.Jobs = append(base.Jobs, j)
	}
	return base
}

func parseDefault(node *yaml.Node) (draft, []Issue) {
	d := draft{present: map[string]bool{}}
	if node.Kind != yaml.MappingNode {
		return d, []Issue{{Line: node.Line, Key: "ci.err.map"}}
	}
	var issues []Issue
	for i := 0; i < len(node.Content); i += 2 {
		key := node.Content[i].Value
		val := node.Content[i+1]
		switch key {
		case "image":
			img, iss := imageOf(val)
			issues = append(issues, iss...)
			d.job.Image = img
			d.present["image"] = true
		case "before_script":
			lines, iss := scriptList(val)
			issues = append(issues, iss...)
			d.job.Before = lines
			d.present["before_script"] = true
		case "after_script":
			lines, iss := scriptList(val)
			issues = append(issues, iss...)
			d.job.After = lines
			d.present["after_script"] = true
		case "tags":
			tags, iss := scalarList(val, "ci.err.list")
			issues = append(issues, iss...)
			d.job.Tags = tags
			d.present["tags"] = true
		case "timeout":
			dur, iss := durationOf(val)
			issues = append(issues, iss...)
			d.job.Timeout = dur
			d.present["timeout"] = true
		case "retry":
			retry, iss := parseRetry(val)
			issues = append(issues, iss...)
			d.job.Retry = retry
			d.present["retry"] = true
		case "interruptible":
			b, iss := parseBool(val)
			issues = append(issues, iss...)
			d.job.Interruptible = b
			d.present["interruptible"] = true
		case "doNotInterrupt":
			b, iss := parseBool(val)
			issues = append(issues, iss...)
			d.job.DoNotInterrupt = b
			d.present["doNotInterrupt"] = true
		case "cache":
			c, iss := parseCache(val)
			issues = append(issues, iss...)
			d.job.Cache = c
			d.present["cache"] = true
		default:
			issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"default." + key}, Warning: true})
		}
	}
	return d, issues
}

func overlayJob(base Job, d draft) Job {
	set := func(key string, apply func()) {
		if d.present[key] {
			apply()
		}
	}
	set("stage", func() { base.Stage = d.job.Stage })
	set("image", func() { base.Image = d.job.Image })
	set("before_script", func() { base.Before = d.job.Before })
	set("script", func() { base.Script = d.job.Script })
	set("after_script", func() { base.After = d.job.After })
	set("needs", func() {
		base.Needs = d.job.Needs
		base.Optional = d.job.Optional
		base.NeedsSet = d.job.NeedsSet
	})
	set("artifacts", func() { base.Artifacts = d.job.Artifacts })
	set("rules", func() { base.Rules = d.job.Rules })
	set("allow_failure", func() { base.AllowFailure = d.job.AllowFailure })
	set("when", func() { base.When = d.job.When })
	set("timeout", func() { base.Timeout = d.job.Timeout })
	set("tags", func() { base.Tags = d.job.Tags })
	set("cache", func() { base.Cache = d.job.Cache })
	set("resource_group", func() { base.ResourceGroup = d.job.ResourceGroup })
	set("only", func() { base.Only = d.job.Only })
	set("except", func() { base.Except = d.job.Except })
	set("retry", func() { base.Retry = d.job.Retry })
	set("parallel", func() {
		base.Parallel = d.job.Parallel
		base.Matrix = d.job.Matrix
	})
	set("services", func() { base.Services = d.job.Services })
	set("environment", func() { base.Environment = d.job.Environment })
	set("interruptible", func() { base.Interruptible = d.job.Interruptible })
	set("doNotInterrupt", func() { base.DoNotInterrupt = d.job.DoNotInterrupt })
	if d.present["variables"] {
		mergedVars := map[string]string{}
		for k, v := range base.Variables {
			mergedVars[k] = v
		}
		for k, v := range d.job.Variables {
			mergedVars[k] = v
		}
		base.Variables = mergedVars
	}
	return base
}

func overlayDefault(base, extra draft) draft {
	if base.present == nil {
		base.present = map[string]bool{}
	}
	for k, on := range extra.present {
		if !on {
			continue
		}
		base.present[k] = true
		switch k {
		case "image":
			base.job.Image = extra.job.Image
		case "before_script":
			base.job.Before = extra.job.Before
		case "after_script":
			base.job.After = extra.job.After
		case "tags":
			base.job.Tags = extra.job.Tags
		case "timeout":
			base.job.Timeout = extra.job.Timeout
		case "cache":
			base.job.Cache = extra.job.Cache
		case "retry":
			base.job.Retry = extra.job.Retry
		case "interruptible":
			base.job.Interruptible = extra.job.Interruptible
		case "doNotInterrupt":
			base.job.DoNotInterrupt = extra.job.DoNotInterrupt
		}
	}
	return base
}

func parseJobMap(node *yaml.Node) ([]draft, []Issue) {
	if node.Kind != yaml.MappingNode {
		return nil, []Issue{{Line: node.Line, Key: "ci.err.jobsMap"}}
	}
	var jobs []draft
	var issues []Issue
	for i := 0; i < len(node.Content); i += 2 {
		job, iss := parseJob(node.Content[i].Value, node.Content[i+1])
		issues = append(issues, iss...)
		if job.job.Name != "" {
			jobs = append(jobs, job)
		}
	}
	return jobs, issues
}

func parseJob(name string, node *yaml.Node) (draft, []Issue) {
	d := draft{present: map[string]bool{}, line: node.Line, job: Job{Name: name, Variables: map[string]string{}}}
	if node.Kind != yaml.MappingNode {
		return d, []Issue{{Line: node.Line, Key: "ci.err.jobMap", Args: []any{name}}}
	}
	var issues []Issue
	for i := 0; i < len(node.Content); i += 2 {
		key := node.Content[i].Value
		val := node.Content[i+1]
		d.present[key] = true
		switch key {
		case "stage":
			if val.Kind != yaml.ScalarNode {
				issues = append(issues, Issue{Line: val.Line, Key: "ci.err.stageText"})
				continue
			}
			d.job.Stage = val.Value
		case "image":
			img, iss := imageOf(val)
			issues = append(issues, iss...)
			d.job.Image = img
		case "before_script":
			lines, iss := scriptList(val)
			issues = append(issues, iss...)
			d.job.Before = lines
		case "script":
			lines, iss := scriptList(val)
			issues = append(issues, iss...)
			d.job.Script = lines
		case "after_script":
			lines, iss := scriptList(val)
			issues = append(issues, iss...)
			d.job.After = lines
		case "needs":
			needs, optional, set, iss := parseNeeds(val)
			issues = append(issues, iss...)
			d.job.Needs = needs
			d.job.Optional = optional
			d.job.NeedsSet = set
		case "variables":
			vars, iss := scalarMap(val)
			issues = append(issues, iss...)
			d.job.Variables = vars
		case "artifacts":
			art, iss := parseArtifacts(val)
			issues = append(issues, iss...)
			d.job.Artifacts = art
		case "rules":
			rules, iss := parseRules(val)
			issues = append(issues, iss...)
			d.job.Rules = rules
		case "allow_failure":
			b, iss := parseBool(val)
			issues = append(issues, iss...)
			d.job.AllowFailure = b
		case "when":
			w, iss := whenOf(val, false)
			issues = append(issues, iss...)
			d.job.When = w
		case "timeout":
			dur, iss := durationOf(val)
			issues = append(issues, iss...)
			d.job.Timeout = dur
		case "tags":
			tags, iss := scalarList(val, "ci.err.list")
			issues = append(issues, iss...)
			d.job.Tags = tags
		case "cache":
			c, iss := parseCache(val)
			issues = append(issues, iss...)
			d.job.Cache = c
		case "resource_group":
			if val.Kind != yaml.ScalarNode || strings.TrimSpace(val.Value) == "" {
				issues = append(issues, Issue{Line: val.Line, Key: "ci.err.resource"})
				continue
			}
			d.job.ResourceGroup = strings.TrimSpace(val.Value)
		case "only":
			list, iss := scalarList(val, "ci.err.list")
			issues = append(issues, iss...)
			d.job.Only = list
		case "except":
			list, iss := scalarList(val, "ci.err.list")
			issues = append(issues, iss...)
			d.job.Except = list
		case "extends":
			list, iss := extendsOf(val)
			issues = append(issues, iss...)
			d.extends = list
		case "retry":
			retry, iss := parseRetry(val)
			issues = append(issues, iss...)
			d.job.Retry = retry
		case "parallel":
			n, matrix, iss := parseParallel(val)
			issues = append(issues, iss...)
			d.job.Parallel = n
			d.job.Matrix = matrix
		case "services":
			svcs, iss := parseServices(val)
			issues = append(issues, iss...)
			d.job.Services = svcs
		case "environment":
			env, iss := parseEnvironment(val)
			issues = append(issues, iss...)
			d.job.Environment = env
		case "interruptible":
			b, iss := parseBool(val)
			issues = append(issues, iss...)
			d.job.Interruptible = b
		case "doNotInterrupt":
			b, iss := parseBool(val)
			issues = append(issues, iss...)
			d.job.DoNotInterrupt = b
		default:
			if _, ok := reserved[key]; ok {
				issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{key}, Warning: true})
				continue
			}
			issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{name + "." + key}, Warning: true})
		}
	}
	return d, issues
}

func applyExtends(jobs []draft, def draft) ([]draft, []Issue) {
	by := map[string]*draft{}
	var order []string
	var issues []Issue
	for i := range jobs {
		name := jobs[i].job.Name
		if by[name] != nil {
			issues = append(issues, Issue{Line: jobs[i].line, Key: "ci.err.jobDup", Args: []any{name}})
			continue
		}
		by[name] = &jobs[i]
		order = append(order, name)
	}
	visiting := map[string]bool{}
	var walk func(string)
	walk = func(name string) {
		d := by[name]
		if d == nil || d.present["__resolved"] {
			return
		}
		if visiting[name] {
			issues = append(issues, Issue{Line: d.line, Key: "ci.err.extendsCycle", Args: []any{name}})
			return
		}
		visiting[name] = true
		for _, parent := range d.extends {
			base := by[parent]
			if base == nil {
				issues = append(issues, Issue{Line: d.line, Key: "ci.err.extends", Args: []any{name, parent}})
				continue
			}
			walk(parent)
			inherit(d, base)
		}
		delete(visiting, name)
		d.present["__resolved"] = true
		inherit(d, &def)
	}
	for _, name := range order {
		walk(name)
	}
	return jobs, issues
}

func inherit(child, parent *draft) {
	if parent == nil {
		return
	}
	copyField := func(key string, apply func()) {
		if child.present[key] || !parent.present[key] {
			return
		}
		apply()
		child.present[key] = true
	}
	copyField("stage", func() { child.job.Stage = parent.job.Stage })
	copyField("image", func() { child.job.Image = parent.job.Image })
	copyField("before_script", func() { child.job.Before = parent.job.Before })
	copyField("script", func() { child.job.Script = parent.job.Script })
	copyField("after_script", func() { child.job.After = parent.job.After })
	copyField("needs", func() {
		child.job.Needs = parent.job.Needs
		child.job.Optional = parent.job.Optional
		child.job.NeedsSet = parent.job.NeedsSet
	})
	copyField("artifacts", func() { child.job.Artifacts = parent.job.Artifacts })
	copyField("rules", func() { child.job.Rules = parent.job.Rules })
	copyField("allow_failure", func() { child.job.AllowFailure = parent.job.AllowFailure })
	copyField("when", func() { child.job.When = parent.job.When })
	copyField("timeout", func() { child.job.Timeout = parent.job.Timeout })
	copyField("tags", func() { child.job.Tags = parent.job.Tags })
	copyField("cache", func() { child.job.Cache = parent.job.Cache })
	copyField("resource_group", func() { child.job.ResourceGroup = parent.job.ResourceGroup })
	copyField("only", func() { child.job.Only = parent.job.Only })
	copyField("except", func() { child.job.Except = parent.job.Except })
	copyField("retry", func() { child.job.Retry = parent.job.Retry })
	copyField("parallel", func() {
		child.job.Parallel = parent.job.Parallel
		child.job.Matrix = parent.job.Matrix
	})
	copyField("services", func() { child.job.Services = parent.job.Services })
	copyField("environment", func() { child.job.Environment = parent.job.Environment })
	copyField("interruptible", func() { child.job.Interruptible = parent.job.Interruptible })
	copyField("doNotInterrupt", func() { child.job.DoNotInterrupt = parent.job.DoNotInterrupt })
	if len(parent.job.Variables) > 0 {
		merged := map[string]string{}
		for k, v := range parent.job.Variables {
			merged[k] = v
		}
		for k, v := range child.job.Variables {
			merged[k] = v
		}
		child.job.Variables = merged
	}
}

func validate(p *Pipeline) []Issue {
	var issues []Issue
	if len(p.Jobs) == 0 {
		return []Issue{{Line: 1, Key: "ci.err.noJobs"}}
	}
	seenStage := map[string]bool{}
	for _, s := range p.Stages {
		if s == "" {
			issues = append(issues, Issue{Line: 1, Key: "ci.err.stageEmpty"})
			continue
		}
		if seenStage[s] {
			issues = append(issues, Issue{Line: 1, Key: "ci.err.stageDup", Args: []any{s}})
		}
		seenStage[s] = true
	}
	if len(p.Stages) == 0 {
		var order []string
		for i := range p.Jobs {
			if p.Jobs[i].Stage == "" {
				p.Jobs[i].Stage = "test"
			}
			if !seenStage[p.Jobs[i].Stage] {
				seenStage[p.Jobs[i].Stage] = true
				order = append(order, p.Jobs[i].Stage)
			}
		}
		p.Stages = order
	}
	names := map[string]bool{}
	for i := range p.Jobs {
		j := &p.Jobs[i]
		if j.Name == "" || strings.ContainsAny(j.Name, " \t\n/\\") {
			issues = append(issues, Issue{Line: 1, Key: "ci.err.jobName", Args: []any{j.Name}})
			continue
		}
		names[j.Name] = true
		if j.Stage == "" {
			issues = append(issues, Issue{Line: 1, Key: "ci.err.jobStage", Args: []any{j.Name}})
		} else if !seenStage[j.Stage] {
			issues = append(issues, Issue{Line: 1, Key: "ci.err.stageUnknown", Args: []any{j.Name, j.Stage}})
		}
		if j.Image == "" {
			j.Image = p.Image
		}
		if strings.TrimSpace(j.Image) == "" || strings.ContainsAny(j.Image, " \t\n") {
			issues = append(issues, Issue{Line: 1, Key: "ci.err.noImage", Args: []any{j.Name}})
		}
		if len(j.Script) == 0 {
			issues = append(issues, Issue{Line: 1, Key: "ci.err.noScript", Args: []any{j.Name}})
		}
		for _, line := range j.Script {
			if strings.TrimSpace(line) == "" {
				issues = append(issues, Issue{Line: 1, Key: "ci.err.emptyLine", Args: []any{j.Name}})
			}
		}
		for _, path := range j.Artifacts.Paths {
			if iss := safeRel(path); iss.Key != "" {
				issues = append(issues, iss)
			}
		}
		for _, path := range j.Cache.Paths {
			if iss := safeRel(path); iss.Key != "" {
				issues = append(issues, iss)
			}
		}
		if j.When == "" {
			j.When = "on_success"
		}
	}
	for _, j := range p.Jobs {
		for _, need := range j.Needs {
			if !names[need] && !contains(j.Optional, need) {
				issues = append(issues, Issue{Line: 1, Key: "ci.err.needUnknown", Args: []any{j.Name, need}})
			}
			if need == j.Name {
				issues = append(issues, Issue{Line: 1, Key: "ci.err.needSelf", Args: []any{j.Name}})
			}
		}
	}
	if iss := detectCycles(p.Jobs); iss.Key != "" {
		issues = append(issues, iss)
	}
	return issues
}

func detectCycles(jobs []Job) Issue {
	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) Issue
	visit = func(i int) Issue {
		if color[i] == gray {
			return Issue{Line: 1, Key: "ci.err.cycle", Args: []any{jobs[i].Name}}
		}
		if color[i] == black {
			return Issue{}
		}
		color[i] = gray
		for _, n := range jobs[i].Needs {
			target, ok := idx[n]
			if !ok {
				continue
			}
			if iss := visit(target); iss.Key != "" {
				return iss
			}
		}
		color[i] = black
		return Issue{}
	}
	for i := range jobs {
		if iss := visit(i); iss.Key != "" {
			return iss
		}
	}
	return Issue{}
}

func parseArtifacts(node *yaml.Node) (Artifacts, []Issue) {
	if node.Kind != yaml.MappingNode {
		return Artifacts{}, []Issue{{Line: node.Line, Key: "ci.err.artifacts"}}
	}
	var a Artifacts
	var issues []Issue
	for i := 0; i < len(node.Content); i += 2 {
		key := node.Content[i].Value
		val := node.Content[i+1]
		switch key {
		case "paths":
			paths, iss := scalarList(val, "ci.err.list")
			issues = append(issues, iss...)
			a.Paths = paths
		case "expire_in":
			if val.Kind != yaml.ScalarNode {
				issues = append(issues, Issue{Line: val.Line, Key: "ci.err.expire"})
				continue
			}
			d, err := parseExpire(val.Value)
			if err != nil {
				issues = append(issues, Issue{Line: val.Line, Key: "ci.err.expireBad", Args: []any{val.Value}})
				continue
			}
			a.ExpireIn = d
		default:
			issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"artifacts." + key}, Warning: true})
		}
	}
	return a, issues
}

func parseCache(node *yaml.Node) (Cache, []Issue) {
	if node.Kind != yaml.MappingNode {
		return Cache{}, []Issue{{Line: node.Line, Key: "ci.err.cache"}}
	}
	var c Cache
	var issues []Issue
	for i := 0; i < len(node.Content); i += 2 {
		key := node.Content[i].Value
		val := node.Content[i+1]
		switch key {
		case "paths":
			paths, iss := scalarList(val, "ci.err.list")
			issues = append(issues, iss...)
			c.Paths = paths
		case "key":
			if val.Kind != yaml.ScalarNode {
				issues = append(issues, Issue{Line: val.Line, Key: "ci.err.cacheKey"})
				continue
			}
			c.Key = val.Value
		default:
			issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"cache." + key}, Warning: true})
		}
	}
	return c, issues
}

func parseRules(node *yaml.Node) ([]Rule, []Issue) {
	if node.Kind != yaml.SequenceNode {
		return nil, []Issue{{Line: node.Line, Key: "ci.err.rulesList"}}
	}
	var rules []Rule
	var issues []Issue
	for _, item := range node.Content {
		if item.Kind != yaml.MappingNode {
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.ruleMap"})
			continue
		}
		var r Rule
		for i := 0; i < len(item.Content); i += 2 {
			key := item.Content[i].Value
			val := item.Content[i+1]
			switch key {
			case "if":
				if val.Kind != yaml.ScalarNode || strings.TrimSpace(val.Value) == "" {
					issues = append(issues, Issue{Line: val.Line, Key: "ci.err.ruleIf"})
					continue
				}
				r.If = strings.TrimSpace(val.Value)
				if err := checkRule(r.If); err != nil {
					if ie, ok := err.(i18n.Error); ok {
						issues = append(issues, Issue{Line: val.Line, Key: ie.Key, Args: ie.Args})
					} else {
						issues = append(issues, Issue{Line: val.Line, Key: "ci.err.ruleExpr", Args: []any{r.If}})
					}
				}
			case "changes":
				list, iss := scalarList(val, "ci.err.list")
				issues = append(issues, iss...)
				r.Changes = list
			case "exists":
				list, iss := scalarList(val, "ci.err.list")
				issues = append(issues, iss...)
				r.Exists = list
			case "when":
				w, iss := whenOf(val, true)
				issues = append(issues, iss...)
				r.When = w
			default:
				issues = append(issues, Issue{Line: item.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"rules." + key}, Warning: true})
			}
		}
		if r.If == "" && len(r.Changes) == 0 && len(r.Exists) == 0 && r.When == "" {
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.ruleEmpty"})
			continue
		}
		rules = append(rules, r)
	}
	return rules, issues
}

func parseNeeds(node *yaml.Node) (needs, optional []string, set bool, issues []Issue) {
	set = true
	if node.Kind != yaml.SequenceNode {
		return nil, nil, true, []Issue{{Line: node.Line, Key: "ci.err.needs"}}
	}
	for _, item := range node.Content {
		switch item.Kind {
		case yaml.ScalarNode:
			needs = append(needs, item.Value)
		case yaml.MappingNode:
			var name string
			var opt bool
			for i := 0; i < len(item.Content); i += 2 {
				switch item.Content[i].Value {
				case "job":
					if item.Content[i+1].Kind == yaml.ScalarNode {
						name = item.Content[i+1].Value
					}
				case "optional":
					b, iss := parseBool(item.Content[i+1])
					issues = append(issues, iss...)
					opt = b
				default:
					issues = append(issues, Issue{Line: item.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"needs." + item.Content[i].Value}, Warning: true})
				}
			}
			if name == "" {
				issues = append(issues, Issue{Line: item.Line, Key: "ci.err.needs"})
				continue
			}
			needs = append(needs, name)
			if opt {
				optional = append(optional, name)
			}
		default:
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.needs"})
		}
	}
	if needs == nil {
		needs = []string{}
	}
	return needs, optional, set, issues
}

func imageOf(node *yaml.Node) (string, []Issue) {
	switch node.Kind {
	case yaml.ScalarNode:
		return node.Value, nil
	case yaml.MappingNode:
		for i := 0; i < len(node.Content); i += 2 {
			if node.Content[i].Value == "name" && node.Content[i+1].Kind == yaml.ScalarNode {
				return node.Content[i+1].Value, nil
			}
		}
		return "", []Issue{{Line: node.Line, Key: "ci.err.image"}}
	default:
		return "", []Issue{{Line: node.Line, Key: "ci.err.image"}}
	}
}

func whenOf(node *yaml.Node, allowNever bool) (string, []Issue) {
	if node.Kind != yaml.ScalarNode {
		return "", []Issue{{Line: node.Line, Key: "ci.err.when", Args: []any{""}}}
	}
	switch node.Value {
	case "on_success", "on_failure", "always", "manual":
		return node.Value, nil
	case "never":
		if allowNever {
			return node.Value, nil
		}
	}
	return "", []Issue{{Line: node.Line, Key: "ci.err.when", Args: []any{node.Value}}}
}

func durationOf(node *yaml.Node) (time.Duration, []Issue) {
	if node.Kind != yaml.ScalarNode {
		return 0, []Issue{{Line: node.Line, Key: "ci.err.timeout", Args: []any{""}}}
	}
	d, err := parseExpire(node.Value)
	if err != nil {
		if strings.HasSuffix(node.Value, "s") {
			n, nerr := strconv.Atoi(strings.TrimSuffix(node.Value, "s"))
			if nerr == nil && n >= 0 {
				return time.Duration(n) * time.Second, nil
			}
		}
		return 0, []Issue{{Line: node.Line, Key: "ci.err.timeout", Args: []any{node.Value}}}
	}
	return d, nil
}

func extendsOf(node *yaml.Node) ([]string, []Issue) {
	if node.Kind == yaml.ScalarNode && strings.TrimSpace(node.Value) != "" {
		return []string{node.Value}, nil
	}
	return scalarList(node, "ci.err.extendsList")
}

func scriptList(node *yaml.Node) ([]string, []Issue) {
	if node.Kind == yaml.ScalarNode {
		if strings.TrimSpace(node.Value) == "" {
			return nil, []Issue{{Line: node.Line, Key: "ci.err.script"}}
		}
		return splitLines(node.Value), nil
	}
	return scalarList(node, "ci.err.script")
}

func splitLines(s string) []string {
	parts := strings.Split(s, "\n")
	var out []string
	for _, p := range parts {
		if strings.TrimSpace(p) == "" {
			continue
		}
		out = append(out, p)
	}
	return out
}

func scalarList(node *yaml.Node, key string) ([]string, []Issue) {
	if node.Kind != yaml.SequenceNode {
		return nil, []Issue{{Line: node.Line, Key: key}}
	}
	var out []string
	var issues []Issue
	for _, item := range node.Content {
		if item.Kind != yaml.ScalarNode {
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.listText"})
			continue
		}
		out = append(out, item.Value)
	}
	return out, issues
}

func scalarMap(node *yaml.Node) (map[string]string, []Issue) {
	if node.Kind != yaml.MappingNode {
		return nil, []Issue{{Line: node.Line, Key: "ci.err.map"}}
	}
	out := map[string]string{}
	var issues []Issue
	for i := 0; i < len(node.Content); i += 2 {
		k := node.Content[i]
		v := node.Content[i+1]
		if k.Kind != yaml.ScalarNode {
			issues = append(issues, Issue{Line: k.Line, Key: "ci.err.varText"})
			continue
		}
		switch v.Kind {
		case yaml.ScalarNode:
			out[k.Value] = v.Value
		case yaml.MappingNode:
			val, iss := mappingValue(v)
			issues = append(issues, iss...)
			if val != "" || len(iss) == 0 {
				out[k.Value] = val
			}
		default:
			issues = append(issues, Issue{Line: v.Line, Key: "ci.err.varText"})
		}
	}
	return out, issues
}

func mappingValue(node *yaml.Node) (string, []Issue) {
	for i := 0; i < len(node.Content); i += 2 {
		if node.Content[i].Value == "value" && node.Content[i+1].Kind == yaml.ScalarNode {
			return node.Content[i+1].Value, nil
		}
	}
	return "", []Issue{{Line: node.Line, Key: "ci.err.varText"}}
}

func parseBool(node *yaml.Node) (bool, []Issue) {
	if node.Kind != yaml.ScalarNode {
		return false, []Issue{{Line: node.Line, Key: "ci.err.bool"}}
	}
	switch strings.ToLower(node.Value) {
	case "true", "yes":
		return true, nil
	case "false", "no":
		return false, nil
	default:
		return false, []Issue{{Line: node.Line, Key: "ci.err.bool"}}
	}
}

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")
	}
	n, err := strconv.Atoi(s[:len(s)-1])
	if err != nil || n < 0 {
		return 0, fmt.Errorf("expire")
	}
	switch s[len(s)-1] {
	case 's':
		return time.Duration(n) * time.Second, nil
	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")
	}
}

func safeRel(p string) Issue {
	if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, "\\") {
		return Issue{Line: 1, Key: "ci.err.rel", Args: []any{p}}
	}
	for _, part := range strings.Split(p, "/") {
		if part == ".." {
			return Issue{Line: 1, Key: "ci.err.dotdot", Args: []any{p}}
		}
	}
	return Issue{}
}

func hasError(issues []Issue) bool {
	for _, is := range issues {
		if !is.Warning {
			return true
		}
	}
	return false
}
