michaelschiemer/tests/debug/test-discovery-service-internals.php

<?php

declare(strict_types=1);

require_once __DIR__ . '/../../vendor/autoload.php';

use App\Framework\Cache\Driver\InMemoryCache;
use App\Framework\Cache\GeneralCache;
use App\Framework\Core\PathProvider;
use App\Framework\DateTime\SystemClock;
use App\Framework\DI\DefaultContainer;
use App\Framework\DI\InitializerMapper;
use App\Framework\Discovery\Factory\DiscoveryServiceFactory;
use App\Framework\Discovery\UnifiedDiscoveryService;
use App\Framework\Discovery\ValueObjects\DiscoveryConfiguration;
use App\Framework\Filesystem\FileSystemService;
use App\Framework\Reflection\CachedReflectionProvider;
use App\Framework\Serializer\Json\JsonSerializer;

echo "=== Comparing UnifiedDiscoveryService Internals ===\n\n";

try {
    $projectRoot = dirname(__DIR__, 2);
    $srcPath = $projectRoot . '/src';

    $container = new DefaultContainer();
    $pathProvider = new PathProvider($projectRoot);
    $clock = new SystemClock();
    $cacheDriver = new InMemoryCache();
    $serializer = new JsonSerializer();
    $cache = new GeneralCache($cacheDriver, $serializer);

    // Factory-based service
    echo "=== Factory-Based Service ===\n";
    $factory = new DiscoveryServiceFactory($container, $pathProvider, $cache, $clock);
    $factoryService = $factory->createForDevelopment([$srcPath]);

    // Direct service
    echo "=== Direct Service ===\n";
    $fileSystemService = new FileSystemService();
    $reflectionProvider = new CachedReflectionProvider();

    $directConfig = new DiscoveryConfiguration(
        paths: [$srcPath],
        attributeMappers: [new InitializerMapper()],
        targetInterfaces: [],
        useCache: false
    );

    $directService = new UnifiedDiscoveryService(
        pathProvider: $pathProvider,
        cache: $cache,
        clock: $clock,
        reflectionProvider: $reflectionProvider,
        configuration: $directConfig,
        attributeMappers: [new InitializerMapper()],
        targetInterfaces: []
    );

    // Compare configurations using reflection
    $factoryReflection = new ReflectionClass($factoryService);
    $directReflection = new ReflectionClass($directService);

    echo "=== Configuration Comparison ===\n";

    // Configuration
    $factoryConfigProp = $factoryReflection->getProperty('configuration');
    $factoryConfigProp->setAccessible(true);
    $factoryConfig = $factoryConfigProp->getValue($factoryService);

    $directConfigProp = $directReflection->getProperty('configuration');
    $directConfigProp->setAccessible(true);
    $directConfigPropValue = $directConfigProp->getValue($directService);

    echo "Factory Config:\n";
    print_r($factoryConfig->toArray());
    echo "\nDirect Config:\n";
    print_r($directConfigPropValue->toArray());

    // Compare attribute mappers
    echo "\n=== Attribute Mappers Comparison ===\n";

    $factoryMappersProp = $factoryReflection->getProperty('attributeMappers');
    $factoryMappersProp->setAccessible(true);
    $factoryMappers = $factoryMappersProp->getValue($factoryService);

    $directMappersProp = $directReflection->getProperty('attributeMappers');
    $directMappersProp->setAccessible(true);
    $directMappers = $directMappersProp->getValue($directService);

    echo "Factory Mappers (" . count($factoryMappers) . "):\n";
    foreach ($factoryMappers as $i => $mapper) {
        echo "  $i: " . get_class($mapper) . "\n";
    }

    echo "\nDirect Mappers (" . count($directMappers) . "):\n";
    foreach ($directMappers as $i => $mapper) {
        echo "  $i: " . get_class($mapper) . "\n";
    }

    // Compare paths
    echo "\n=== Paths Comparison ===\n";
    echo "Factory paths: " . json_encode($factoryConfig->paths) . "\n";
    echo "Direct paths: " . json_encode($directConfigPropValue->paths) . "\n";

    // Check other possible differences
    echo "\n=== Other Properties ===\n";

    $factoryFileSystemProp = $factoryReflection->getProperty('fileSystemService');
    $factoryFileSystemProp->setAccessible(true);
    $factoryFileSystem = $factoryFileSystemProp->getValue($factoryService);

    $directFileSystemProp = $directReflection->getProperty('fileSystemService');
    $directFileSystemProp->setAccessible(true);
    $directFileSystem = $directFileSystemProp->getValue($directService);

    echo "Factory FileSystemService: " . ($factoryFileSystem ? get_class($factoryFileSystem) : 'null') . "\n";
    echo "Direct FileSystemService: " . ($directFileSystem ? get_class($directFileSystem) : 'null') . "\n";

    $factoryReflectionProp = $factoryReflection->getProperty('reflectionProvider');
    $factoryReflectionProp->setAccessible(true);
    $factoryReflectionProvider = $factoryReflectionProp->getValue($factoryService);

    $directReflectionProp = $directReflection->getProperty('reflectionProvider');
    $directReflectionProp->setAccessible(true);
    $directReflectionProvider = $directReflectionProp->getValue($directService);

    echo "Factory ReflectionProvider: " . get_class($factoryReflectionProvider) . "\n";
    echo "Direct ReflectionProvider: " . get_class($directReflectionProvider) . "\n";

    // Now run both discoveries and compare the exact process
    echo "\n=== Discovery Process Comparison ===\n";

    echo "Running factory discovery...\n";
    $factoryRegistry = $factoryService->discover();
    echo "Factory result: " . count($factoryRegistry) . " total, " .
         $factoryRegistry->attributes->getCount('App\\Framework\\DI\\Initializer') . " initializers\n";

    echo "Running direct discovery...\n";
    $directRegistry = $directService->discover();
    echo "Direct result: " . count($directRegistry) . " total, " .
         $directRegistry->attributes->getCount('App\\Framework\\DI\\Initializer') . " initializers\n";

} catch (Exception $e) {
    echo "❌ Error: " . $e->getMessage() . "\n";
    echo "Stack trace:\n" . $e->getTraceAsString() . "\n";
}