<?php

declare(strict_types=1);

use App\Support\References\Contracts\ReferenceResolver;
use App\Support\References\ReferenceClass;
use App\Support\References\ReferenceDescriptor;
use App\Support\References\ReferenceResolutionState;
use App\Support\References\ReferenceResolverRegistry;
use App\Support\References\ReferenceTechnicalDetail;
use App\Support\References\ResolvedReference;
use App\Support\References\Resolvers\FallbackReferenceResolver;

it('dispatches to the matching resolver', function (): void {
    $resolver = new class implements ReferenceResolver
    {
        public function referenceClass(): ReferenceClass
        {
            return ReferenceClass::Policy;
        }

        public function resolve(ReferenceDescriptor $descriptor): ResolvedReference
        {
            return new ResolvedReference(
                referenceClass: $descriptor->referenceClass,
                rawIdentifier: $descriptor->rawIdentifier,
                primaryLabel: 'Matched policy',
                secondaryLabel: null,
                state: ReferenceResolutionState::Resolved,
                stateLabel: null,
                linkTarget: null,
                technicalDetail: ReferenceTechnicalDetail::forIdentifier($descriptor->rawIdentifier),
            );
        }
    };

    $registry = new ReferenceResolverRegistry(
        resolvers: [$resolver],
        fallbackResolver: new FallbackReferenceResolver,
    );

    $resolved = $registry->resolve(new ReferenceDescriptor(
        referenceClass: ReferenceClass::Policy,
        rawIdentifier: '17',
    ));

    expect($resolved->primaryLabel)->toBe('Matched policy');
});

it('falls back for unsupported classes', function (): void {
    $registry = new ReferenceResolverRegistry(
        resolvers: [],
        fallbackResolver: new FallbackReferenceResolver,
    );

    $resolved = $registry->resolve(new ReferenceDescriptor(
        referenceClass: ReferenceClass::Unsupported,
        rawIdentifier: 'raw-guid',
        fallbackLabel: 'Stored fallback',
    ));

    expect($resolved->state)->toBe(ReferenceResolutionState::PartiallyResolved)
        ->and($resolved->primaryLabel)->toBe('Stored fallback');
});
