<?php

declare(strict_types=1);

namespace App\Framework\Analytics;

use App\Framework\Analytics\Bridges\SecurityEventBridge;
use App\Framework\Analytics\Listeners\SecurityAnalyticsListener;
use App\Framework\Analytics\Storage\AnalyticsStorage;
use App\Framework\Analytics\Storage\PerformanceBasedAnalyticsStorage;
use App\Framework\Config\Environment;
use App\Framework\DI\Container;
use App\Framework\DI\Initializer;
use App\Framework\Filesystem\AtomicStorage;
use App\Framework\Filesystem\Serializer;
use App\Framework\Filesystem\Serializers\JsonSerializer;
use App\Framework\Filesystem\Storage;
use App\Framework\Http\ServerEnvironment;
use App\Framework\Performance\Contracts\PerformanceCollectorInterface;
use App\Framework\Random\SecureRandomGenerator;

/**
 * Analytics-System Initializer
 *
 * Registriert alle Analytics-Komponenten im DI-Container
 */
final readonly class AnalyticsInitializer
{
    public function __construct(
        private Environment $environment,
    ){}

    #[Initializer]
    public function initializeAnalytics(Container $container): void
    {
        // Analytics Config
        $container->singleton(AnalyticsConfig::class, function () {
            return AnalyticsConfig::fromEnvironment($this->environment);
        });

        // Core Analytics Storage
        $container->singleton(AnalyticsStorage::class, function (Container $container) {
            $config = $container->get(AnalyticsConfig::class);

            // Get filesystem dependencies
            $storage = $container->has(AtomicStorage::class)
                ? $container->get(AtomicStorage::class)
                : $container->get(Storage::class);

            $serializer = $container->has(Serializer::class)
                ? $container->get(Serializer::class)
                : new JsonSerializer();

            return new PerformanceBasedAnalyticsStorage(
                $container->get(PerformanceCollectorInterface::class),
                $storage,
                $serializer,
                $config->dataPath
            );
        });

        // Analytics Collector
        $container->singleton(AnalyticsCollector::class, function (Container $container) {
            $config = $container->get(AnalyticsConfig::class);

            return new AnalyticsCollector(
                $container->get(PerformanceCollectorInterface::class),
                $container->get(AnalyticsStorage::class),
                new SecureRandomGenerator(),
                $container->get(ServerEnvironment::class),
                enabled: $config->enabled,
                samplingRate: $config->samplingRate
            );
        });

        // Security Analytics Integration
        $container->singleton(SecurityAnalyticsListener::class, function (Container $container) {
            $config = $container->get(AnalyticsConfig::class);

            return new SecurityAnalyticsListener(
                $container->get(AnalyticsCollector::class),
                enabled: $config->securityAnalyticsEnabled
            );
        });

        $container->singleton(SecurityEventBridge::class, function (Container $container) {
            $config = $container->get(AnalyticsConfig::class);

            return SecurityEventBridge::create(
                $container->get(SecurityAnalyticsListener::class),
                enabled: $config->securityAnalyticsEnabled
            );
        });
    }
}