package usecase

import (
	"context"
	"fmt"
	"strings"

	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
)

type resolvedPromptDefinition struct {
	definition *domain.PromptDefinition
	hash       string
}

type promptInspectionRepository interface {
	GetPromptInspection(context.Context, string) (*domain.PromptInspection, error)
}

func (r *Runner) resolvePromptDefinition(ctx context.Context, promptID string) (*resolvedPromptDefinition, error) {
	if strings.TrimSpace(promptID) == "" {
		return nil, fmt.Errorf("%w: prompt id is required", ErrInvalidRequest)
	}
	if r == nil || r.promptDefs == nil {
		return nil, fmt.Errorf("%w: prompt repository is not configured", ErrPromptLoad)
	}

	var definition *domain.PromptDefinition
	var hash string
	var err error
	if indexed, ok := r.promptDefs.(interface {
		GetPromptSnapshot(context.Context, string) (*domain.PromptDefinition, string, error)
	}); ok {
		definition, hash, err = indexed.GetPromptSnapshot(ctx, promptID)
	} else {
		definition, err = r.promptDefs.GetPromptDefinition(ctx, promptID)
	}
	if err != nil {
		return nil, fmt.Errorf("%w: %w", ErrPromptLoad, err)
	}
	if definition == nil {
		return nil, fmt.Errorf("%w: prompt repository returned nil definition", ErrPromptLoad)
	}

	if hash == "" {
		hash, err = hashPromptDefinition(definition)
		if err != nil {
			return nil, fmt.Errorf("%w: failed to hash prompt definition: %v", ErrPromptLoad, err)
		}
	}
	return &resolvedPromptDefinition{definition: definition, hash: hash}, nil
}

func (r *Runner) resolvePromptInspection(ctx context.Context, promptID string) (*domain.PromptInspection, error) {
	if strings.TrimSpace(promptID) == "" {
		return nil, fmt.Errorf("%w: prompt id is required", ErrInvalidRequest)
	}
	if r == nil || r.promptDefs == nil {
		return nil, fmt.Errorf("%w: prompt repository is not configured", ErrPromptLoad)
	}
	if indexed, ok := r.promptDefs.(promptInspectionRepository); ok {
		inspection, err := indexed.GetPromptInspection(ctx, promptID)
		if err != nil {
			return nil, fmt.Errorf("%w: %w", ErrPromptLoad, err)
		}
		if inspection == nil {
			return nil, fmt.Errorf("%w: prompt repository returned nil inspection", ErrPromptLoad)
		}
		return inspection, nil
	}

	selection, err := r.resolvePromptDefinition(ctx, promptID)
	if err != nil {
		return nil, err
	}
	definition := selection.definition
	return &domain.PromptInspection{
		PromptID:         definition.ID,
		PromptVersion:    definition.Version,
		PromptHash:       selection.hash,
		DefaultProfileID: definition.DefaultProfile,
		Inputs:           append([]domain.PromptInput(nil), definition.Inputs...),
		OutputContract:   definition.Validation,
	}, nil
}

// InspectPrompt resolves one explicit prompt without execution work.
func (r *Runner) InspectPrompt(ctx context.Context, promptID string) (*domain.PromptInspection, error) {
	if strings.TrimSpace(promptID) == "" {
		return nil, fmt.Errorf("%w: prompt id is required", ErrInvalidRequest)
	}
	select {
	case <-ctx.Done():
		return nil, fmt.Errorf("%w: %w", ErrPromptLoad, ctx.Err())
	default:
	}

	return r.resolvePromptInspection(ctx, promptID)
}