using ChatApi.Data;
using ChatRAG.Contracts.VectorSearch;
using ChatRAG.Services.Contracts;
using ChatRAG.Services.ResponseService;
using ChatRAG.Services.TextServices;
using ChatRAG.Settings.ChatRAG.Configuration;
using Microsoft.Extensions.Options;

namespace ChatRAG.Services.SearchVectors
{
    /// <summary>
    /// Factory principal que cria implementações baseadas na configuração
    /// </summary>
    /// <summary>
    /// Factory principal que cria implementações baseadas na configuração
    /// </summary>
    public class VectorDatabaseFactory : IVectorDatabaseFactory
    {
        private readonly VectorDatabaseSettings _settings;
        private readonly IServiceProvider _serviceProvider;
        private readonly ILogger<VectorDatabaseFactory> _logger;

        public VectorDatabaseFactory(
            IOptions<VectorDatabaseSettings> settings,
            IServiceProvider serviceProvider,
            ILogger<VectorDatabaseFactory> logger)
        {
            _settings = settings.Value;
            _serviceProvider = serviceProvider;
            _logger = logger;

            // Valida configurações na inicialização
            ValidateSettings();
        }

        public string GetActiveProvider() => _settings.Provider;
        public VectorDatabaseSettings GetSettings() => _settings;

        public IVectorSearchService CreateVectorSearchService()
        {
            _logger.LogInformation("Criando VectorSearchService para provider: {Provider}", _settings.Provider);

            return _settings.Provider.ToLower() switch
            {
                "qdrant" => GetService<ChatRAG.Services.SearchVectors.QdrantVectorSearchService>(),
                "mongodb" => GetService<ChatRAG.Services.SearchVectors.MongoVectorSearchService>(),
                _ => throw new ArgumentException($"Provider de VectorSearch não suportado: {_settings.Provider}")
            };
        }

        public ITextDataService CreateTextDataService()
        {
            _logger.LogInformation("Criando TextDataService para provider: {Provider}", _settings.Provider);

            return _settings.Provider.ToLower() switch
            {
                // ✅ CORRIGIDO: Usa os namespaces corretos
                "qdrant" => GetService<ChatRAG.Services.TextServices.QdrantTextDataService>(),
                "mongodb" => GetService<ChatApi.Data.TextData>(), // Sua classe atual!
                _ => throw new ArgumentException($"Provider de TextData não suportado: {_settings.Provider}")
            };
        }

        public IResponseService CreateResponseService()
        {
            _logger.LogInformation("Criando ResponseService para provider: {Provider}", _settings.Provider);

            return _settings.Provider.ToLower() switch
            {
                // ✅ CORRIGIDO: Usa os namespaces corretos
                "qdrant" => GetService<ChatRAG.Services.ResponseService.QdrantResponseService>(),
                "mongodb" => GetService<ChatRAG.Services.ResponseService.ResponseRAGService>(), // Sua classe atual!
                _ => throw new ArgumentException($"Provider de Response não suportado: {_settings.Provider}")
            };
        }

        // ========================================
        // MÉTODOS AUXILIARES
        // ========================================

        private T GetService<T>() where T : class
        {
            try
            {
                var service = _serviceProvider.GetRequiredService<T>();
                _logger.LogDebug("Serviço {ServiceType} criado com sucesso", typeof(T).Name);
                return service;
            }
            catch (InvalidOperationException ex)
            {
                _logger.LogError(ex, "Erro ao criar serviço {ServiceType} para provider {Provider}",
                    typeof(T).Name, _settings.Provider);

                throw new InvalidOperationException(
                    $"Serviço {typeof(T).Name} não está registrado para provider {_settings.Provider}. " +
                    $"Certifique-se de chamar services.Add{_settings.Provider}Provider() no DI.", ex);
            }
        }

        private void ValidateSettings()
        {
            if (!_settings.IsValid())
            {
                var errors = _settings.GetValidationErrors();
                var errorMessage = $"Configurações inválidas para VectorDatabase: {string.Join(", ", errors)}";

                _logger.LogError(errorMessage);
                throw new InvalidOperationException(errorMessage);
            }

            _logger.LogInformation("Configurações validadas com sucesso para provider: {Provider}", _settings.Provider);
        }
    }
}