package profile

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"gitea.maximumdirect.net/eric/scriptorium/internal/domain"
	"gitea.maximumdirect.net/eric/scriptorium/internal/filecatalog"
	"gopkg.in/yaml.v3"
)

var (
	ErrProfileNotFound     = errors.New("execution profile not found")
	ErrInvalidYAML         = errors.New("invalid YAML format")
	ErrInvalidProfile      = errors.New("invalid execution profile configuration")
	ErrRawAPIKeyNotAllowed = errors.New("raw api_key is not allowed; use api_key_env")
)

type filesystemRepository struct {
	dir string
}

func NewFilesystemRepository(dir string) Repository {
	return &filesystemRepository{dir: dir}
}

func (r *filesystemRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
	if strings.TrimSpace(id) == "" {
		return nil, fmt.Errorf("%w: profile id is required", ErrInvalidProfile)
	}

	files, err := filecatalog.FindYAMLFiles(ctx, r.dir)
	if err != nil {
		return nil, fmt.Errorf("failed to read profile directory: %w", err)
	}

	var matches []profileMatch
	for _, fullPath := range files {
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		default:
		}

		relPath := filecatalog.RelativePath(r.dir, fullPath)
		fileMatch := filecatalog.Stem(filepath.Base(fullPath)) == id
		data, err := os.ReadFile(fullPath)
		if err != nil {
			return nil, fmt.Errorf("failed to read profile file %s: %w", relPath, err)
		}

		var prof domain.ExecutionProfile
		decoder := yaml.NewDecoder(bytes.NewReader(data))
		decoder.KnownFields(true)
		if err := decoder.Decode(&prof); err != nil {
			idMatch := fileMatch || profileFileHasID(data, id)
			if strings.Contains(err.Error(), "field api_key not found") {
				if idMatch {
					return nil, fmt.Errorf("%w: %s", ErrRawAPIKeyNotAllowed, relPath)
				}
				continue
			}
			if idMatch {
				return nil, fmt.Errorf("%w: %s: %v", ErrInvalidYAML, relPath, err)
			}
			continue
		}

		if prof.ID != id {
			continue
		}
		if err := validateProfile(&prof); err != nil {
			if errors.Is(err, ErrRawAPIKeyNotAllowed) {
				return nil, fmt.Errorf("%w: %s", err, relPath)
			}
			return nil, fmt.Errorf("%w: %s: %v", ErrInvalidProfile, relPath, err)
		}
		matches = append(matches, profileMatch{
			profile: &prof,
			path:    relPath,
		})
	}

	if len(matches) > 1 {
		paths := make([]string, 0, len(matches))
		for _, match := range matches {
			paths = append(paths, match.path)
		}
		return nil, fmt.Errorf("%w: duplicate execution profile id %q found in: %s", ErrInvalidProfile, id, strings.Join(paths, ", "))
	}

	if len(matches) == 1 {
		return matches[0].profile, nil
	}

	return nil, ErrProfileNotFound
}

type profileMatch struct {
	profile *domain.ExecutionProfile
	path    string
}

func profileFileHasID(data []byte, id string) bool {
	var raw struct {
		ID string `yaml:"id"`
	}
	if err := yaml.NewDecoder(bytes.NewReader(data)).Decode(&raw); err != nil {
		return false
	}
	return strings.TrimSpace(raw.ID) == id
}

func validateProfile(p *domain.ExecutionProfile) error {
	if strings.TrimSpace(p.ID) == "" {
		return errors.New("id is required")
	}
	if strings.TrimSpace(p.Endpoint) == "" {
		return errors.New("endpoint is required")
	}
	if strings.TrimSpace(p.Model) == "" {
		return errors.New("model is required")
	}

	if p.Temperature < 0 || p.Temperature > 2 {
		return errors.New("temperature must be between 0 and 2")
	}
	if p.MaxTokens < 0 {
		return errors.New("max_tokens must be greater than or equal to 0")
	}
	if p.TopP < 0 || p.TopP > 1 {
		return errors.New("top_p must be between 0 and 1")
	}
	if p.TimeoutSeconds < 0 {
		return errors.New("timeout_seconds must be greater than or equal to 0")
	}

	return nil
}