<?php

declare(strict_types=1);

// @responsibility: Register Chat bounded context services in DI container

namespace ServiceProvider;

use Domain\Repository\ChatMessageRepositoryInterface;
use Domain\Repository\ChatSessionRepositoryInterface;
use Domain\Repository\ChunkRepositoryInterface;
use Domain\Repository\ContentConfigRepositoryInterface;
use Domain\Repository\PromptsRepositoryInterface;
use Domain\Service\ModelRegistryInterface;
use Framework\Container;
use Infrastructure\AI\AIConfig;
use Infrastructure\AI\ChatService;
use Infrastructure\AI\ClaudeService;
use Infrastructure\AI\ContentQualityValidator;
use Infrastructure\AI\ModelRegistry;
use Infrastructure\AI\OllamaService;
use Infrastructure\AI\QdrantClient;
use Infrastructure\AI\QdrantService;
use Infrastructure\AI\ScoringService;
use Infrastructure\AI\SemanticEnrichmentService;
use Infrastructure\AI\VectorSearchService;
use Infrastructure\Formatting\ChatMessageFormatter;
use Infrastructure\Logging\KiProtokollService;
use Infrastructure\Persistence\ChatMessageRepository;
use Infrastructure\Persistence\ChatSessionRepository;
use Infrastructure\Persistence\ChunkRepository;
use Infrastructure\Persistence\ContentConfigRepository;
use Infrastructure\Persistence\CriticsRepository;
use Infrastructure\Persistence\PromptsRepository;
use UseCases\Chat\ChatPromptLoader;
use UseCases\Chat\CreateChatSessionUseCase;
use UseCases\Chat\CreateChatSessionUseCaseInterface;
use UseCases\Chat\DeleteChatSessionUseCase;
use UseCases\Chat\DeleteChatSessionUseCaseInterface;
use UseCases\Chat\GetChatSessionUseCase;
use UseCases\Chat\GetChatSessionUseCaseInterface;
use UseCases\Chat\RagContextBuilder;
use UseCases\Chat\SendChatMessageUseCase;
use UseCases\Chat\StreamingChatMessageUseCase;
use UseCases\Chat\UpdateChatSessionUseCase;
use UseCases\Chat\UpdateChatSessionUseCaseInterface;

/**
 * ChatServiceProvider registers all chat and AI-related services.
 */
final class ChatServiceProvider implements ServiceProviderInterface
{
    public function register(Container $container): void
    {
        // Repositories
        $container->set(ChatSessionRepository::class, fn (Container $c) => new ChatSessionRepository($c->get('pdo.content')));
        $container->set(ChatMessageRepository::class, fn (Container $c) => new ChatMessageRepository($c->get('pdo.content')));
        $container->set(PromptsRepository::class, fn (Container $c) => new PromptsRepository($c->get('pdo.content')));
        $container->set(CriticsRepository::class, fn (Container $c) => new CriticsRepository($c->get('pdo.content')));
        $container->set(ContentConfigRepository::class, fn (Container $c) => new ContentConfigRepository($c->get('pdo.content')));

        // Interface aliases
        $container->set(ChatSessionRepositoryInterface::class, fn (Container $c) => $c->get(ChatSessionRepository::class));
        $container->set(ChatMessageRepositoryInterface::class, fn (Container $c) => $c->get(ChatMessageRepository::class));
        $container->set(PromptsRepositoryInterface::class, fn (Container $c) => $c->get(PromptsRepository::class));
        $container->set(ContentConfigRepositoryInterface::class, fn (Container $c) => $c->get(ContentConfigRepository::class));

        // AI Services
        $container->set(AIConfig::class, fn () => AIConfig::fromCredentialsFile());
        $container->set(OllamaService::class, fn (Container $c) => $c->get(AIConfig::class)->createOllamaService());
        $container->set(QdrantService::class, fn (Container $c) => $c->get(AIConfig::class)->createQdrantService());
        $container->set(ClaudeService::class, fn (Container $c) => $c->get(AIConfig::class)->createClaudeService());
        $container->set(ScoringService::class, fn () => new ScoringService());
        $container->set(VectorSearchService::class, fn () => new VectorSearchService());
        $container->set(QdrantClient::class, fn () => new QdrantClient());

        // Chunk Repository for semantic enrichment
        $container->set(ChunkRepository::class, fn (Container $c) => new ChunkRepository($c->get('pdo.content')));
        $container->set(ChunkRepositoryInterface::class, fn (Container $c) => $c->get(ChunkRepository::class));

        // Semantic Enrichment Service (for Graceful Degradation)
        $container->set(SemanticEnrichmentService::class, fn (Container $c) => new SemanticEnrichmentService(
            $c->get(ChunkRepositoryInterface::class)
        ));

        // ChatService with Semantic Enrichment (Graceful Degradation)
        $container->set(ChatService::class, fn (Container $c) => new ChatService(
            $c->get(OllamaService::class),
            $c->get(QdrantService::class),
            $c->get(ClaudeService::class),
            $c->get(ScoringService::class),
            $c->get(SemanticEnrichmentService::class)
        ));

        $container->set(ContentQualityValidator::class, function (Container $c) {
            return new ContentQualityValidator($c->get(OllamaService::class));
        });

        $container->set(ModelRegistry::class, function (Container $c) {
            $registry = new ModelRegistry($c->get('pdo.dev'));
            ModelRegistry::setInstance($registry);

            return $registry;
        });

        $container->set(ModelRegistryInterface::class, fn (Container $c) => $c->get(ModelRegistry::class));

        // Formatters
        $container->set(ChatMessageFormatter::class, fn () => new ChatMessageFormatter());

        // Use Cases
        $container->set(UpdateChatSessionUseCase::class, function (Container $c) {
            return new UpdateChatSessionUseCase(
                $c->get(ChatSessionRepositoryInterface::class),
                $c->get(ContentConfigRepositoryInterface::class),
                $c->get(\Domain\Repository\CollectionRepositoryInterface::class),
                $c->get(\Infrastructure\Validation\CollectionValidator::class),
                $c->get(ModelRegistryInterface::class),
                $c->get('pdo.dev')
            );
        });

        $container->set(UpdateChatSessionUseCaseInterface::class, fn (Container $c) => $c->get(UpdateChatSessionUseCase::class));

        $container->set(CreateChatSessionUseCase::class, function (Container $c) {
            return new CreateChatSessionUseCase(
                $c->get(ChatSessionRepositoryInterface::class),
                $c->get(ModelRegistryInterface::class)
            );
        });

        $container->set(CreateChatSessionUseCaseInterface::class, fn (Container $c) => $c->get(CreateChatSessionUseCase::class));

        $container->set(GetChatSessionUseCase::class, function (Container $c) {
            return new GetChatSessionUseCase(
                $c->get(ChatSessionRepositoryInterface::class),
                $c->get(ChatMessageRepositoryInterface::class),
                $c->get(ContentConfigRepositoryInterface::class),
                $c->get(\Domain\Repository\CollectionRepositoryInterface::class)
            );
        });

        $container->set(GetChatSessionUseCaseInterface::class, fn (Container $c) => $c->get(GetChatSessionUseCase::class));

        $container->set(DeleteChatSessionUseCase::class, function (Container $c) {
            return new DeleteChatSessionUseCase(
                $c->get(ChatSessionRepositoryInterface::class)
            );
        });

        $container->set(DeleteChatSessionUseCaseInterface::class, fn (Container $c) => $c->get(DeleteChatSessionUseCase::class));

        // Chat Helper Services
        $container->set(ChatPromptLoader::class, fn (Container $c) => new ChatPromptLoader(
            $c->get(ContentConfigRepositoryInterface::class)
        ));

        $container->set(RagContextBuilder::class, fn (Container $c) => new RagContextBuilder(
            $c->get(\Domain\Service\SearchServiceInterface::class)
        ));

        // Streaming UseCase with extracted helpers
        $container->set(StreamingChatMessageUseCase::class, function (Container $c) {
            return new StreamingChatMessageUseCase(
                $c->get(OllamaService::class),
                $c->get(QdrantService::class),
                $c->get(ClaudeService::class),
                $c->get(ScoringService::class),
                $c->get(ChatSessionRepositoryInterface::class),
                $c->get(ChatMessageRepositoryInterface::class),
                $c->get(ChatPromptLoader::class),
                $c->get(ContentQualityValidator::class),
                $c->get(RagContextBuilder::class),
                $c->get(KiProtokollService::class)
            );
        });

        // Non-streaming UseCase
        $container->set(SendChatMessageUseCase::class, function (Container $c) {
            return new SendChatMessageUseCase(
                $c->get(ChatService::class),
                $c->get(ChatSessionRepositoryInterface::class),
                $c->get(ChatMessageRepositoryInterface::class),
                $c->get(ChatPromptLoader::class),
                $c->get(ContentQualityValidator::class)
            );
        });
    }
}