<?php

declare(strict_types=1);

namespace Tests\Framework\Discovery\Storage\ValueObjects;

use App\Framework\Core\ValueObjects\Timestamp;
use App\Framework\Discovery\Results\AttributeRegistry;
use App\Framework\Discovery\Results\DiscoveryRegistry;
use App\Framework\Discovery\Results\InterfaceRegistry;
use App\Framework\Discovery\Results\TemplateRegistry;
use App\Framework\Discovery\Storage\ValueObjects\CacheEntry;
use App\Framework\Discovery\ValueObjects\CacheLevel;
use App\Framework\Discovery\ValueObjects\CacheTier;

use function Pest\Faker\faker;

describe('CacheEntry', function () {
    it('creates entry with DiscoveryRegistry', function () {
        $registry = new DiscoveryRegistry(
            attributes: new AttributeRegistry(),
            interfaces: new InterfaceRegistry(),
            templates: new TemplateRegistry()
        );
        
        $createdAt = Timestamp::fromDateTime(new \DateTimeImmutable('2024-01-01 12:00:00'));
        $entry = new CacheEntry(
            registry: $registry,
            createdAt: $createdAt,
            version: 'v1-abc12345',
            cacheLevel: CacheLevel::NORMAL,
            cacheTier: CacheTier::HOT
        );
        
        expect($entry->registry)->toBe($registry);
        expect($entry->createdAt)->toBe($createdAt);
        expect($entry->version)->toBe('v1-abc12345');
        expect($entry->cacheLevel)->toBe(CacheLevel::NORMAL);
        expect($entry->cacheTier)->toBe(CacheTier::HOT);
        expect($entry->isCompressed())->toBeFalse();
    });
    
    it('creates entry with compressed array', function () {
        $compressedData = ['__discovery_compressed__' => true, 'data' => 'compressed'];
        
        $createdAt = new \DateTimeImmutable('2024-01-01 12:00:00');
        $entry = new CacheEntry(
            registry: $compressedData,
            createdAt: $createdAt,
            version: 'v1-abc12345',
            cacheLevel: CacheLevel::EXTENDED,
            cacheTier: CacheTier::ARCHIVE
        );
        
        expect($entry->isCompressed())->toBeTrue();
        expect($entry->registry)->toBe($compressedData);
    });
    
    it('creates from array', function () {
        $registry = new DiscoveryRegistry(
            attributes: new AttributeRegistry(),
            interfaces: new InterfaceRegistry(),
            templates: new TemplateRegistry()
        );
        
        $createdAt = Timestamp::fromDateTime(new \DateTimeImmutable('2024-01-01 12:00:00'));
        $data = [
            'registry' => $registry,
            'startTime' => $createdAt->toTimestamp(),
            'version' => 'v1-abc12345',
            'cacheLevel' => CacheLevel::NORMAL->value,
            'cacheTier' => CacheTier::HOT->value,
        ];
        
        $entry = CacheEntry::fromArray($data);
        
        expect($entry->registry)->toBe($registry);
        expect($entry->createdAt->toTimestamp())->toBe($createdAt->toTimestamp());
        expect($entry->version)->toBe('v1-abc12345');
        expect($entry->cacheLevel)->toBe(CacheLevel::NORMAL);
        expect($entry->cacheTier)->toBe(CacheTier::HOT);
    });
    
    it('converts to array', function () {
        $registry = new DiscoveryRegistry(
            attributes: new AttributeRegistry(),
            interfaces: new InterfaceRegistry(),
            templates: new TemplateRegistry()
        );
        
        $createdAt = Timestamp::fromDateTime(new \DateTimeImmutable('2024-01-01 12:00:00'));
        $entry = new CacheEntry(
            registry: $registry,
            createdAt: $createdAt,
            version: 'v1-abc12345',
            cacheLevel: CacheLevel::NORMAL,
            cacheTier: CacheTier::HOT
        );
        
        $array = $entry->toArray();
        
        expect($array)->toBeArray();
        expect($array['registry'])->toBe($registry);
        expect($array['startTime'])->toBe($createdAt->toTimestamp());
        expect($array['version'])->toBe('v1-abc12345');
        expect($array['cacheLevel'])->toBe(CacheLevel::NORMAL->value);
        expect($array['cacheTier'])->toBe(CacheTier::HOT->value);
    });
    
    it('throws exception when getting registry from compressed entry', function () {
        $compressedData = ['__discovery_compressed__' => true, 'data' => 'compressed'];
        
        $entry = new CacheEntry(
            registry: $compressedData,
            createdAt: Timestamp::now(),
            version: 'v1-abc12345',
            cacheLevel: CacheLevel::NORMAL,
            cacheTier: CacheTier::HOT
        );
        
        expect(fn() => $entry->getRegistry())->toThrow(\RuntimeException::class);
    });
});