package ci

import (
	"strconv"
	"strings"

	"gopkg.in/yaml.v3"
)

func parseWorkflow(node *yaml.Node) ([]Rule, []Issue) {
	if node.Kind != yaml.MappingNode {
		return nil, []Issue{{Line: node.Line, Key: "ci.err.map"}}
	}
	var rules []Rule
	var issues []Issue
	for i := 0; i < len(node.Content); i += 2 {
		key := node.Content[i].Value
		val := node.Content[i+1]
		if key == "rules" {
			parsed, iss := parseRules(val)
			issues = append(issues, iss...)
			rules = parsed
			continue
		}
		issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"workflow." + key}, Warning: true})
	}
	return rules, issues
}

func parseRetry(node *yaml.Node) (Retry, []Issue) {
	switch node.Kind {
	case yaml.ScalarNode:
		n, iss := retryMax(node)
		if len(iss) > 0 && n == 0 && iss[0].Key != "ci.warn.retryMax" {
			return Retry{}, iss
		}
		return Retry{Max: n}, iss
	case yaml.MappingNode:
		var retry Retry
		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 "max":
				n, iss := retryMax(val)
				issues = append(issues, iss...)
				retry.Max = n
			case "when":
				list, iss := retryWhen(val)
				issues = append(issues, iss...)
				retry.When = list
			default:
				issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"retry." + key}, Warning: true})
			}
		}
		return retry, issues
	default:
		return Retry{}, []Issue{{Line: node.Line, Key: "ci.err.retry"}}
	}
}

func retryMax(node *yaml.Node) (int, []Issue) {
	if node.Kind != yaml.ScalarNode {
		return 0, []Issue{{Line: node.Line, Key: "ci.err.retry"}}
	}
	n, err := strconv.Atoi(strings.TrimSpace(node.Value))
	if err != nil || n < 0 {
		return 0, []Issue{{Line: node.Line, Key: "ci.err.retry"}}
	}
	if n > 2 {
		return 2, []Issue{{Line: node.Line, Key: "ci.warn.retryMax", Args: []any{n, 2}, Warning: true}}
	}
	return n, nil
}

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

func parseParallel(node *yaml.Node) (int, []MatrixSpec, []Issue) {
	if node.Kind == yaml.ScalarNode {
		n, err := strconv.Atoi(strings.TrimSpace(node.Value))
		if err != nil || n < 1 {
			return 0, nil, []Issue{{Line: node.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}}
		}
		if n > maxParallel {
			return 0, nil, []Issue{{Line: node.Line, Key: "ci.err.parallel", Args: []any{n, maxParallel}}}
		}
		return n, nil, nil
	}
	if node.Kind != yaml.MappingNode {
		return 0, nil, []Issue{{Line: node.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}}
	}
	var specs []MatrixSpec
	var issues []Issue
	seen := false
	for i := 0; i < len(node.Content); i += 2 {
		key := node.Content[i].Value
		val := node.Content[i+1]
		if key != "matrix" {
			issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"parallel." + key}, Warning: true})
			continue
		}
		seen = true
		parsed, iss := parseMatrix(val)
		issues = append(issues, iss...)
		specs = parsed
	}
	if !seen {
		issues = append(issues, Issue{Line: node.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}})
	}
	count := 0
	for _, spec := range specs {
		count += len(cartesian(spec))
	}
	if count > maxParallel {
		issues = append(issues, Issue{Line: node.Line, Key: "ci.err.parallel", Args: []any{count, maxParallel}})
	}
	return 0, specs, issues
}

func parseMatrix(node *yaml.Node) ([]MatrixSpec, []Issue) {
	if node.Kind != yaml.SequenceNode || len(node.Content) == 0 {
		return nil, []Issue{{Line: node.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}}}
	}
	var specs []MatrixSpec
	var issues []Issue
	for _, item := range node.Content {
		if item.Kind != yaml.MappingNode {
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}})
			continue
		}
		spec := MatrixSpec{}
		for i := 0; i < len(item.Content); i += 2 {
			key := item.Content[i].Value
			vals, iss := matrixValues(item.Content[i+1])
			issues = append(issues, iss...)
			if len(vals) == 0 {
				continue
			}
			spec.Keys = append(spec.Keys, key)
			spec.Vals = append(spec.Vals, vals)
		}
		if len(spec.Keys) == 0 {
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.parallelForm", Args: []any{maxParallel}})
			continue
		}
		specs = append(specs, spec)
	}
	return specs, issues
}

func matrixValues(node *yaml.Node) ([]string, []Issue) {
	if node.Kind == yaml.ScalarNode {
		return []string{node.Value}, nil
	}
	return scalarList(node, "ci.err.list")
}

func parseServices(node *yaml.Node) ([]Service, []Issue) {
	var items []*yaml.Node
	switch node.Kind {
	case yaml.SequenceNode:
		items = node.Content
	default:
		items = []*yaml.Node{node}
	}
	var out []Service
	var issues []Issue
	for _, item := range items {
		switch item.Kind {
		case yaml.ScalarNode:
			if strings.TrimSpace(item.Value) == "" {
				issues = append(issues, Issue{Line: item.Line, Key: "ci.err.service"})
				continue
			}
			out = append(out, Service{Name: item.Value, Alias: serviceAlias(item.Value)})
		case yaml.MappingNode:
			svc := Service{Variables: map[string]string{}}
			for i := 0; i < len(item.Content); i += 2 {
				key := item.Content[i].Value
				val := item.Content[i+1]
				switch key {
				case "name":
					if val.Kind == yaml.ScalarNode {
						svc.Name = val.Value
					}
				case "alias":
					if val.Kind == yaml.ScalarNode {
						svc.Alias = val.Value
					}
				case "command":
					list, iss := scriptList(val)
					issues = append(issues, iss...)
					svc.Command = list
				case "entrypoint":
					list, iss := scriptList(val)
					issues = append(issues, iss...)
					svc.Entrypoint = list
				case "variables":
					vars, iss := scalarMap(val)
					issues = append(issues, iss...)
					svc.Variables = vars
				default:
					issues = append(issues, Issue{Line: item.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"services." + key}, Warning: true})
				}
			}
			if strings.TrimSpace(svc.Name) == "" {
				issues = append(issues, Issue{Line: item.Line, Key: "ci.err.service"})
				continue
			}
			if svc.Alias == "" {
				svc.Alias = serviceAlias(svc.Name)
			}
			out = append(out, svc)
		default:
			issues = append(issues, Issue{Line: item.Line, Key: "ci.err.service"})
		}
	}
	return out, issues
}

func serviceAlias(image string) string {
	name := image
	if i := strings.LastIndex(name, "/"); i >= 0 {
		name = name[i+1:]
	}
	if i := strings.IndexAny(name, ":@"); i >= 0 {
		name = name[:i]
	}
	name = strings.TrimSpace(name)
	if name == "" {
		return "service"
	}
	return name
}

func parseEnvironment(node *yaml.Node) (Environment, []Issue) {
	switch node.Kind {
	case yaml.ScalarNode:
		if strings.TrimSpace(node.Value) == "" {
			return Environment{}, []Issue{{Line: node.Line, Key: "ci.err.environment"}}
		}
		return Environment{Name: node.Value}, nil
	case yaml.MappingNode:
		var env Environment
		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 "name":
				if val.Kind == yaml.ScalarNode {
					env.Name = val.Value
				}
			case "url":
				if val.Kind == yaml.ScalarNode {
					env.URL = val.Value
				}
			default:
				issues = append(issues, Issue{Line: node.Content[i].Line, Key: "ci.warn.ignored", Args: []any{"environment." + key}, Warning: true})
			}
		}
		if strings.TrimSpace(env.Name) == "" {
			issues = append(issues, Issue{Line: node.Line, Key: "ci.err.environment"})
		}
		return env, issues
	default:
		return Environment{}, []Issue{{Line: node.Line, Key: "ci.err.environment"}}
	}
}
