package ci

import (
	"fmt"
	"path"
	"regexp"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/i18n"
)

// Variables zet de voorgedefinieerde CI_-variabelen. Job-specifieke namen
// vult de runner zelf aan.
func Variables(r Ref) map[string]string {
	name := r.Name
	kind := r.Kind
	if kind == "" {
		name, kind = SplitRef(r.FullRef)
	}
	short := r.SHA
	if len(short) > 8 {
		short = short[:8]
	}
	project := r.ProjectPath
	ns, base := splitProject(project)
	env := map[string]string{
		"CI":                   "true",
		"CI_CONFIG_PATH":       "blue-ci-cd.yml",
		"CI_SERVER_NAME":       "BlueGit",
		"CI_COMMIT_SHA":        r.SHA,
		"CI_COMMIT_SHORT_SHA":  short,
		"CI_COMMIT_REF":        r.FullRef,
		"CI_COMMIT_REF_NAME":   name,
		"CI_COMMIT_REF_SLUG":   slug(name),
		"CI_COMMIT_TITLE":      r.Title,
		"CI_COMMIT_BRANCH":     "",
		"CI_COMMIT_TAG":        "",
		"CI_DEFAULT_BRANCH":    r.DefaultBranch,
		"CI_PIPELINE_ID":       fmt.Sprint(r.PipelineID),
		"CI_PIPELINE_SOURCE":   r.Source,
		"CI_PIPELINE_URL":      strings.TrimRight(r.ProjectURL, "/") + "/-/pipelines/" + fmt.Sprint(r.PipelineID),
		"CI_PROJECT_PATH":      project,
		"CI_PROJECT_NAME":      base,
		"CI_PROJECT_NAMESPACE": ns,
		"CI_PROJECT_URL":       r.ProjectURL,
		"CI_API_URL":           r.APIURL,
	}
	if kind == "tag" {
		env["CI_COMMIT_TAG"] = name
	} else {
		env["CI_COMMIT_BRANCH"] = name
	}
	if env["CI_PIPELINE_SOURCE"] == "" {
		env["CI_PIPELINE_SOURCE"] = "push"
	}
	return env
}

// SplitRef haalt de korte naam en het soort uit refs/heads of refs/tags.
func SplitRef(ref string) (name, kind string) {
	switch {
	case strings.HasPrefix(ref, "refs/tags/"):
		return strings.TrimPrefix(ref, "refs/tags/"), "tag"
	case strings.HasPrefix(ref, "refs/heads/"):
		return strings.TrimPrefix(ref, "refs/heads/"), "branch"
	default:
		return ref, "branch"
	}
}

func splitProject(path string) (ns, name string) {
	i := strings.LastIndex(path, "/")
	if i < 0 {
		return "", path
	}
	return path[:i], path[i+1:]
}

func slug(s string) string {
	var b strings.Builder
	prev := false
	for _, r := range strings.ToLower(s) {
		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
			b.WriteRune(r)
			prev = false
			continue
		}
		if !prev && b.Len() > 0 {
			b.WriteByte('-')
			prev = true
		}
	}
	return strings.Trim(b.String(), "-")
}

// Select houdt de jobs waarvan de rules, only en except kloppen.
// De When van de job wordt de when van de winnende rule.
func (p Pipeline) Select(ev Eval) ([]Job, error) {
	if ev.Env == nil {
		ev.Env = map[string]string{}
	}
	var out []Job
	active := map[string]bool{}
	var pending []Job
	for _, j := range p.Jobs {
		ok, when, err := j.matches(ev)
		if err != nil {
			return nil, fmt.Errorf("job %s: %w", j.Name, err)
		}
		if !ok {
			continue
		}
		if when == "" {
			when = "on_success"
		}
		j.When = when
		pending = append(pending, j)
		active[j.Name] = true
	}
	for i := range pending {
		var needs []string
		for _, n := range pending[i].Needs {
			if active[n] {
				needs = append(needs, n)
				continue
			}
			if contains(pending[i].Optional, n) {
				continue
			}
			needs = append(needs, n)
		}
		if needs == nil {
			needs = []string{}
		}
		pending[i].Needs = needs
		out = append(out, pending[i])
	}
	return out, nil
}

// ActiveJobs is Select met alleen variabelen. changes en exists gelden dan als waar.
func (p Pipeline) ActiveJobs(env map[string]string) ([]Job, error) {
	return p.Select(Eval{Env: env})
}

func (j Job) matches(ev Eval) (bool, string, error) {
	when := j.When
	if when == "" {
		when = "on_success"
	}
	if len(j.Rules) == 0 {
		ok, err := onlyExcept(j, ev)
		return ok, when, err
	}
	for _, r := range j.Rules {
		ok, err := ruleMatch(r, ev)
		if err != nil {
			return false, "", err
		}
		if !ok {
			continue
		}
		w := r.When
		if w == "" {
			w = when
		}
		if w == "never" {
			return false, w, nil
		}
		return true, w, nil
	}
	return false, "", nil
}

func ruleMatch(r Rule, ev Eval) (bool, error) {
	if r.If != "" {
		ok, err := evalRule(r.If, ev.Env)
		if err != nil || !ok {
			return ok, err
		}
	}
	if len(r.Changes) > 0 && ev.Changed != nil {
		if !anyGlob(r.Changes, ev.Changed) {
			return false, nil
		}
	}
	if len(r.Exists) > 0 && ev.Files != nil {
		if !allExist(r.Exists, ev.Files) {
			return false, nil
		}
	}
	if r.If == "" && len(r.Changes) == 0 && len(r.Exists) == 0 && r.When == "" {
		return false, nil
	}
	return true, nil
}

func onlyExcept(j Job, ev Eval) (bool, error) {
	if len(j.Only) == 0 && len(j.Except) == 0 {
		return true, nil
	}
	name := ev.Env["CI_COMMIT_REF_NAME"]
	if name == "" {
		name = ev.Env["CI_COMMIT_BRANCH"]
	}
	tag := ev.Env["CI_COMMIT_TAG"] != ""
	if len(j.Only) > 0 {
		ok, err := refListed(j.Only, name, tag)
		if err != nil || !ok {
			return false, err
		}
	}
	if len(j.Except) > 0 {
		ok, err := refListed(j.Except, name, tag)
		if err != nil {
			return false, err
		}
		if ok {
			return false, nil
		}
	}
	return true, nil
}

func refListed(list []string, name string, tag bool) (bool, error) {
	for _, item := range list {
		switch item {
		case "branches":
			if !tag {
				return true, nil
			}
		case "tags":
			if tag {
				return true, nil
			}
		default:
			if strings.HasPrefix(item, "/") && strings.HasSuffix(item, "/") && len(item) > 2 {
				re, err := regexp.Compile(item[1 : len(item)-1])
				if err != nil {
					return false, i18n.E("ci.err.regex", item, err.Error())
				}
				if re.MatchString(name) {
					return true, nil
				}
				continue
			}
			if item == name {
				return true, nil
			}
		}
	}
	return false, nil
}

func anyGlob(patterns, names []string) bool {
	for _, name := range names {
		for _, pattern := range patterns {
			if Glob(pattern, name) {
				return true
			}
		}
	}
	return false
}

func allExist(patterns, files []string) bool {
	for _, pattern := range patterns {
		found := false
		for _, file := range files {
			if file == pattern || Glob(pattern, file) {
				found = true
				break
			}
		}
		if !found {
			return false
		}
	}
	return true
}

// Glob volgt GitLab-padpatronen: * blijft in één segment, ** loopt door mappen.
func Glob(pattern, name string) bool {
	pattern = strings.TrimPrefix(pattern, "/")
	name = strings.TrimPrefix(name, "/")
	if pattern == name {
		return true
	}
	re := globRegexp(pattern)
	if re.MatchString(name) {
		return true
	}
	if !strings.Contains(pattern, "/") && re.MatchString(path.Base(name)) {
		return true
	}
	return false
}

func globRegexp(pattern string) *regexp.Regexp {
	var b strings.Builder
	b.WriteString("^")
	for i := 0; i < len(pattern); i++ {
		if pattern[i] == '*' && i+1 < len(pattern) && pattern[i+1] == '*' {
			b.WriteString(".*")
			i++
			if i+1 < len(pattern) && pattern[i+1] == '/' {
				i++
			}
			continue
		}
		switch pattern[i] {
		case '*':
			b.WriteString("[^/]*")
		case '?':
			b.WriteString("[^/]")
		default:
			b.WriteString(regexp.QuoteMeta(pattern[i : i+1]))
		}
	}
	b.WriteString("$")
	return regexp.MustCompile(b.String())
}

// 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,
// of dat when: on_failure geen mislukking zag.
// "fail" betekent dat een verplichte need niet in deze pipeline zit.
//
// 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
	}
	optional := map[string]bool{}
	for _, n := range job.Optional {
		optional[n] = true
	}
	var deps []Job
	if job.NeedsSet {
		for _, n := range job.Needs {
			d, ok := byName[n]
			if !ok {
				if optional[n] {
					continue
				}
				return "fail"
			}
			deps = append(deps, d)
		}
	} 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)
			}
		}
	}
	failedAny := false
	failedHard := false
	for _, d := range deps {
		switch status[d.Name] {
		case "success", "skipped":
			continue
		case "failed":
			failedAny = true
			if !d.AllowFailure {
				failedHard = true
			}
		case "manual":
			if d.AllowFailure {
				continue
			}
			return "wait"
		default:
			return "wait"
		}
	}
	when := job.When
	if when == "" {
		when = "on_success"
	}
	switch when {
	case "always":
		return "ready"
	case "on_failure":
		if failedAny {
			return "ready"
		}
		return "skip"
	default:
		if failedHard {
			return "skip"
		}
		return "ready"
	}
}

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

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

func compileRule(expr string) (compiledRule, error) {
	expr = strings.TrimSpace(expr)
	if strings.Contains(expr, "&&") || strings.Contains(expr, "||") {
		return compiledRule{}, i18n.E("ci.err.ruleCombine", expr)
	}
	if m := reEq.FindStringSubmatch(expr); m != nil {
		return compiledRule{kind: "eq", name: m[1], arg: m[2], other: m[3], null: m[2] == "" && m[3] == "" && strings.HasSuffix(strings.TrimSpace(expr), "null")}, nil
	}
	if m := reNe.FindStringSubmatch(expr); m != nil {
		return compiledRule{kind: "ne", name: m[1], arg: m[2], other: m[3], null: m[2] == "" && m[3] == "" && strings.HasSuffix(strings.TrimSpace(expr), "null")}, nil
	}
	if m := reRe.FindStringSubmatch(expr); m != nil {
		re, err := regexp.Compile(m[2])
		if err != nil {
			return compiledRule{}, i18n.E("ci.err.regex", expr, err.Error())
		}
		return compiledRule{kind: "re", name: m[1], re: re}, nil
	}
	if m := reNRe.FindStringSubmatch(expr); m != nil {
		re, err := regexp.Compile(m[2])
		if err != nil {
			return compiledRule{}, i18n.E("ci.err.regex", expr, err.Error())
		}
		return compiledRule{kind: "nre", name: m[1], re: re}, nil
	}
	return compiledRule{}, i18n.E("ci.err.ruleExpr", 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]
	right := c.arg
	if c.other != "" {
		right = env[c.other]
	}
	if c.null {
		right = ""
	}
	switch c.kind {
	case "eq":
		return val == right, nil
	case "ne":
		return val != right, nil
	case "re":
		return c.re.MatchString(val), nil
	case "nre":
		return !c.re.MatchString(val), nil
	default:
		return false, i18n.E("ci.err.ruleExpr", expr)
	}
}

func contains(list []string, s string) bool {
	for _, item := range list {
		if item == s {
			return true
		}
	}
	return false
}
