package profile

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

	"gitea.maximumdirect.net/eric/scriptorium/internal/domain"
	"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 := os.ReadDir(r.dir)
	if err != nil {
		return nil, fmt.Errorf("failed to read profile directory: %w", err)
	}

	for _, file := range files {
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		default:
		}

		if file.IsDir() || (!strings.HasSuffix(file.Name(), ".yaml") && !strings.HasSuffix(file.Name(), ".yml")) {
			continue
		}

		fullPath := filepath.Join(r.dir, file.Name())
		data, err := os.ReadFile(fullPath)
		if err != nil {
			return nil, fmt.Errorf("failed to read profile file %s: %w", file.Name(), err)
		}

		var prof domain.ExecutionProfile
		decoder := yaml.NewDecoder(bytes.NewReader(data))
		decoder.KnownFields(true)
		if err := decoder.Decode(&prof); err != nil {
			if strings.Contains(err.Error(), "field api_key not found") {
				if strings.TrimSuffix(strings.TrimSuffix(file.Name(), ".yaml"), ".yml") == id {
					return nil, fmt.Errorf("%w: %s", ErrRawAPIKeyNotAllowed, file.Name())
				}
				continue
			}
			if strings.TrimSuffix(strings.TrimSuffix(file.Name(), ".yaml"), ".yml") == id {
				return nil, fmt.Errorf("%w: %s: %v", ErrInvalidYAML, file.Name(), 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, file.Name())
			}
			return nil, fmt.Errorf("%w: %s: %v", ErrInvalidProfile, file.Name(), err)
		}
		return &prof, nil
	}

	return nil, ErrProfileNotFound
}

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
}