package gitlabcivalidator

import (
	"errors"
	"fmt"
)

// ValidateGitLabCIFile — главная точка входа в библиотеку.
// Принимает на вход содержимое GitLab CI-файла (в формате YAML) и опции валидации.
// Возвращает ошибку, если есть проблемы в конфигурации (или nil, если всё хорошо).
func ValidateGitLabCIFile(content string, opts ValidationOptions) error {
	validationErr := &ValidationError{}

	// 1) Проверяем, что содержимое не пустое
	if len(content) == 0 {
		validationErr.Add(errors.New("файл .gitlab-ci.yml пуст или отсутствует"))
		return validationErr
	}

	// 2) Парсим YAML
	cfg, err := ParseGitLabCIConfig([]byte(content))
	if err != nil {
		validationErr.Add(fmt.Errorf("ошибка синтаксического анализа YAML: %w", err))
		return validationErr
	}

	// 3) (Опционально) Проверяем SHA проекта,
	//    если включена опция и "проект с заданным SHA существует, но SHA не содержится ни в одной ветке/теге"
	if opts.VerifyProjectSHA && opts.ProjectSHA != "" {
		// Заглушка: предположим, что проект существует,
		// а также предположим, что SHA нигде не встречается
		// (в реальном мире тут нужно обращаться к GitLab API).
		shaExists := checkSHAExistsInBranchesOrTags(opts.ProjectSHA)
		if !shaExists {
			validationErr.Add(fmt.Errorf("указанный SHA (%s) не содержится ни в одной ветке или теге", opts.ProjectSHA))
		}
	}

	// 4) Валидируем структуру конфигурации
	validateRootObject(cfg, validationErr)
	validateJobs(cfg, validationErr)

	if !validationErr.IsEmpty() {
		return validationErr
	}

	return nil
}

// checkSHAExistsInBranchesOrTags - фейковая функция для проверки SHA.
// В реальном проекте здесь вы бы обращались к GitLab API / репозиторию.
func checkSHAExistsInBranchesOrTags(sha string) bool {
	// Для демонстрации пусть всегда возвращает false,
	// т.е. "SHA не найден".
	return false
}

// validateRootObject проверяет допустимые ключи на корневом уровне.
func validateRootObject(cfg *GitLabCIConfig, ve *ValidationError) {
	// Допустимые ключи на корне
	/*allowedKeys := map[string]struct{}{
		"default":       {},
		"include":       {},
		"before_script": {},
		"image":         {},
		"services":      {},
		"after_script":  {},
		"variables":     {},
		"stages":        {},
		"cache":         {},
		"workflow":      {},
		"jobs":          {},
	}*/

	// Поскольку мы уже распарсили в структуру GitLabCIConfig,
	// у нас нет возможности напрямую посмотреть "лишние" ключи,
	// так как yaml.Unmarshal их "отбрасывает".
	//
	// В реальном случае можно было бы воспользоваться механизмом
	// "yaml.UnmarshalStrict" или собственной реализацией обхода
	// узлов YAML. Ниже — упрощённый пример проверки "строгим" способом.
	//
	// Для демонстрации можно парсить в виде map[string]interface{},
	// а затем проверить. Для краткости — опущено.

	// Проверим, что cfg.Stages - это действительно срез строк
	// (если он есть) — базовая проверка типа.
	// В реальном коде при Unmarshal строка превращается в nil,
	// так что здесь слегка условно:
	for i, s := range cfg.Stages {
		if s == "" {
			ve.Add(fmt.Errorf("stages[%d] содержит пустую строку", i))
		}
	}
}

// validateJobs проводит серию проверок для job'ов.
func validateJobs(cfg *GitLabCIConfig, ve *ValidationError) {
	if cfg.Jobs == nil || len(cfg.Jobs) == 0 {
		ve.Add(errors.New("отсутствуют job'ы (jobs) в конфигурации"))
		return
	}

	// Список допустимых стадий, определённых в cfg.Stages
	stagesAllowed := make(map[string]struct{})
	for _, st := range cfg.Stages {
		stagesAllowed[st] = struct{}{}
	}

	// Проверим наличие хотя бы одной "видимой" задачи
	// (под "видимой" обычно понимается job без точки впереди имени,
	// но деталь зависит от бизнес-логики; здесь покажем упрощённо).
	visibleCount := 0

	// 1. Сбор данных для проверки циклов зависимости
	//    (Graph: jobName -> список зависимых jobName).
	dependencyGraph := make(map[string][]string)

	for _, job := range cfg.Jobs {
		// a) Имя задачи не может быть пустым
		if job.Name == "" {
			ve.Add(fmt.Errorf("у задачи отсутствует имя"))
			continue
		}

		// b) Если имя начинается с точки, считаем job скрытым
		if job.Name[0] != '.' {
			visibleCount++
		}

		// c) Обязательное поле script
		scriptPresent := job.Script != nil
		// Проверка на булевые значения и массивы строк можно реализовать
		// дополнительно; здесь для примера выводим только общую идею.
		if !scriptPresent && job.Run == nil {
			ve.Add(fmt.Errorf("задача '%s' не содержит script или run", job.Name))
		}

		// d) Проверка взаимоисключения ключей script и run
		if job.Script != nil && job.Run != nil {
			ve.Add(fmt.Errorf("задача '%s' содержит одновременно script и run", job.Name))
		}

		// e) stage должен быть в списке допустимых
		if job.Stage != "" {
			if _, ok := stagesAllowed[job.Stage]; !ok {
				ve.Add(fmt.Errorf("задача '%s' (строка %d, символ %d) имеет недопустимый stage '%s'",
					job.Name, job.Line, job.Column, job.Stage))
			}
		}

		// f) Dependencies (если есть) должны ссылаться на определённые job
		dependencyGraph[job.Name] = append(dependencyGraph[job.Name], job.Dependencies...)
		for _, dep := range job.Dependencies {
			depPos, _ := job.DependencyLines[dep]
			if _, ok := cfg.Jobs[dep]; !ok {
				ve.Add(fmt.Errorf("задача '%s' (строка %d, символ %d) имеет зависимость '%s' (строка %d, символ %d), которой нет среди job'ов",
					job.Name, job.Line, job.Column, dep, depPos.Line, depPos.Column))
			} else {
				// Проверяем порядок stage (зависимость не должна быть позже)
				if !checkStageOrder(cfg, dep, job.Name) {
					ve.Add(fmt.Errorf("задача '%s' имеет зависимость '%s' со стадией, идущей позже, чем '%s'", job.Name, dep, job.Name))
				}
			}
		}

		// g) Needs — проверки дублирования, наличия и пр.
		if len(job.Needs) > 0 {
			needNames := make(map[string]struct{})
			for _, nd := range job.Needs {
				// Не должно быть дублирующихся name
				if _, exist := needNames[nd.Name]; exist {
					ve.Add(fmt.Errorf("задача '%s' содержит дублирующуюся зависимость '%s' в needs", job.Name, nd.Name))
				} else {
					needNames[nd.Name] = struct{}{}
				}

				// Имя в needs не должно быть пустым
				if nd.Name == "" {
					ve.Add(fmt.Errorf("задача '%s' имеет needs с пустым именем задачи", job.Name))
				}

				// Проверка максимальной длины имени
				if len(nd.Name) > MaxJobNameLength {
					ve.Add(fmt.Errorf("задача '%s' содержит needs '%s', длина имени задачи превышает %d",
						job.Name, nd.Name, MaxJobNameLength))
				}

				// Проверка, что такая задача есть в списке job'ов
				if _, ok := cfg.Jobs[nd.Name]; !ok {
					ve.Add(fmt.Errorf("задача '%s' ссылается на несуществующую задачу '%s' в needs", job.Name, nd.Name))
				} else {
					// Проверяем порядок stage
					if !checkStageOrder(cfg, nd.Name, job.Name) {
						ve.Add(fmt.Errorf("задача '%s' имеет need '%s' со стадией, идущей позже, чем '%s'", job.Name, nd.Name, job.Name))
					}
				}

				// Добавляем в граф для дальнейшей проверки циклов
				dependencyGraph[job.Name] = append(dependencyGraph[job.Name], nd.Name)
			}
		}
	}

	if visibleCount == 0 {
		ve.Add(errors.New("в разделе jobs не обнаружено ни одной «видимой» задачи"))
	}

	// 2. Проверяем граф зависимостей на отсутствие циклов
	if hasCycles := checkCircularDependencies(dependencyGraph); hasCycles {
		ve.Add(errors.New("обнаружены циклические зависимости в заданиях"))
	}
}

// checkStageOrder проверяет, что stage у jobDep не позже, чем stage у jobName
func checkStageOrder(cfg *GitLabCIConfig, jobDep, jobName string) bool {
	depStage := cfg.Jobs[jobDep].Stage
	jobStage := cfg.Jobs[jobName].Stage

	// Если stage пустые, условимся, что порядок "любопытен",
	// но в реальном GitLab это тоже может вызывать ошибки.
	if depStage == "" || jobStage == "" {
		return true // условно пропустим
	}

	allStages := cfg.Stages

	depIndex := -1
	jobIndex := -1
	for i, st := range allStages {
		if st == depStage {
			depIndex = i
		}
		if st == jobStage {
			jobIndex = i
		}
	}

	// Если не нашли stage, тоже пропустим, ибо сам факт уже поднимался выше
	if depIndex == -1 || jobIndex == -1 {
		return true
	}

	// Зависимость не должна иметь stage с индексом больше, чем у job
	return depIndex <= jobIndex
}

// checkCircularDependencies анализирует граф зависимостей и проверяет наличие циклов.
// Здесь применяется простой DFS.
func checkCircularDependencies(graph map[string][]string) bool {
	visited := make(map[string]bool)
	recStack := make(map[string]bool)

	for node := range graph {
		if dfsHasCycle(node, graph, visited, recStack) {
			return true
		}
	}
	return false
}

func dfsHasCycle(node string, graph map[string][]string, visited, recStack map[string]bool) bool {
	if !visited[node] {
		// Отмечаем текущий узел как посещённый
		visited[node] = true
		recStack[node] = true

		// Рекурсивно для всех соседей
		for _, neighbor := range graph[node] {
			if !visited[neighbor] && dfsHasCycle(neighbor, graph, visited, recStack) {
				return true
			} else if recStack[neighbor] {
				return true
			}
		}
	}
	recStack[node] = false
	return false
}