package model

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"voicesnap/internal/paths"
)

type resolveCandidate struct {
	dir           string
	sourceDirKind string
	fromState     bool
}

func ResolveModel(modelID string) (ResolvedModel, error) {
	return ResolveModelInRoot(modelID, paths.ModelsRoot())
}

func ResolveModelInRoot(modelID, modelsRoot string) (ResolvedModel, error) {
	profile, err := GetModelProfile(modelID)
	if err != nil {
		return ResolvedModel{}, err
	}

	result := ResolvedModel{
		ModelID:       profile.ID,
		Profile:       profile,
		BackendKind:   profile.BackendKind,
		ProviderOrder: append([]string(nil), profile.ProviderOrder...),
		Status:        ModelNotInstalled,
		Files:         make(map[string]string),
	}

	state, stateErr := LoadInstallStateFromRoot(modelsRoot)
	if stateErr != nil {
		result.Problems = append(result.Problems, fmt.Sprintf("state invalid: %v", stateErr))
	}

	candidates := make([]resolveCandidate, 0, 3)
	seen := make(map[string]bool)
	stateCandidateFailed := stateErr != nil
	addCandidate := func(relOrAbs, sourceDirKind string, fromState bool) {
		if relOrAbs == "" {
			return
		}
		if fromState && !validStateRelativePath(relOrAbs) {
			stateCandidateFailed = true
			result.Problems = append(result.Problems, fmt.Sprintf("state path escapes models root: %s", relOrAbs))
			return
		}
		dir := filepath.Join(modelsRoot, relOrAbs)
		clean := filepath.Clean(dir)
		if seen[clean] {
			return
		}
		seen[clean] = true
		candidates = append(candidates, resolveCandidate{
			dir:           clean,
			sourceDirKind: sourceDirKind,
			fromState:     fromState,
		})
	}

	if state != nil {
		if installed, ok := state.InstalledModels[profile.ID]; ok {
			addCandidate(installed.Path, installed.SourceDirKind, true)
		}
	}
	addCandidate(profile.InstallDirName, "new", false)
	for _, legacy := range profile.LegacyDirNames {
		addCandidate(legacy, "legacy", false)
	}

	anyDirExists := false
	var lastValidation ValidationResult
	var existingInvalidValidation ValidationResult

	for _, candidate := range candidates {
		if directoryExists(candidate.dir) {
			anyDirExists = true
		}

		validation := ValidateModelDir(profile, candidate.dir)
		if validation.Valid {
			result.RootDir = candidate.dir
			result.SourceDirKind = candidate.sourceDirKind
			result.Files = validation.Files
			if stateCandidateFailed {
				result.Status = ModelStateInvalidFallbackFound
			} else {
				result.Status = ModelInstalledValid
			}
			return result, nil
		}

		lastValidation = validation
		if directoryExists(candidate.dir) && !validation.Valid && len(existingInvalidValidation.Missing) == 0 && len(existingInvalidValidation.Problems) == 0 {
			existingInvalidValidation = validation
		}
		if candidate.fromState {
			stateCandidateFailed = true
			result.Problems = append(result.Problems, validation.Problems...)
		}
	}

	switch {
	case stateCandidateFailed:
		result.Status = ModelStateInvalidNoFallback
	case anyDirExists:
		result.Status = ModelInstalledIncomplete
		result.Missing = append(result.Missing, existingInvalidValidation.Missing...)
		result.Problems = append(result.Problems, existingInvalidValidation.Problems...)
	default:
		result.Status = ModelNotInstalled
		result.Missing = append(result.Missing, lastValidation.Missing...)
		result.Problems = append(result.Problems, lastValidation.Problems...)
	}

	return result, nil
}

func directoryExists(path string) bool {
	info, err := os.Stat(path)
	return err == nil && info.IsDir()
}

func validStateRelativePath(path string) bool {
	if filepath.IsAbs(path) {
		return false
	}
	clean := filepath.Clean(path)
	return clean != "." && clean != ".." && !strings.HasPrefix(clean, ".."+string(os.PathSeparator))
}