<?php

declare(strict_types=1);

use App\Support\Badges\BadgeCatalog;
use App\Support\Badges\BadgeDomain;
use App\Support\Badges\BadgeSpec;
use App\Support\Badges\OperatorNextActionPolicy;
use App\Support\Badges\OperatorOutcomeTaxonomy;
use App\Support\Badges\OperatorSemanticAxis;
use App\Support\Badges\OperatorStateClassification;

it('defines curated examples for the first-slice adoption set', function (): void {
    expect(OperatorOutcomeTaxonomy::curatedExamples())->toHaveCount(17);
});

it('registers taxonomy metadata for every first-slice entry', function (): void {
    foreach (OperatorOutcomeTaxonomy::all() as $entries) {
        foreach ($entries as $entry) {
            expect($entry['axis'])->toBeInstanceOf(OperatorSemanticAxis::class)
                ->and($entry['classification'])->toBeInstanceOf(OperatorStateClassification::class)
                ->and($entry['next_action_policy'])->toBeInstanceOf(OperatorNextActionPolicy::class)
                ->and($entry['label'])->not->toBe('')
                ->and($entry['notes'])->not->toBe('');
        }
    }
});

it('qualifies overloaded operator-facing labels in the first slice', function (): void {
    expect(BadgeCatalog::spec(BadgeDomain::OperationRunStatus, 'queued')->label)->toBe('Queued for execution')
        ->and(BadgeCatalog::spec(BadgeDomain::OperationRunOutcome, 'blocked')->label)->toBe('Blocked by prerequisite')
        ->and(BadgeCatalog::spec(BadgeDomain::EvidenceCompleteness, 'missing')->label)->toBe('Not collected yet')
        ->and(BadgeCatalog::spec(BadgeDomain::EnvironmentReviewCompleteness, 'stale')->label)->toBe('Refresh review inputs')
        ->and(BadgeCatalog::spec(BadgeDomain::BaselineSnapshotFidelity, 'unsupported')->label)->toBe('Support limited')
        ->and(BadgeCatalog::spec(BadgeDomain::BaselineSnapshotLifecycle, 'building')->label)->toBe('Building')
        ->and(BadgeCatalog::spec(BadgeDomain::BaselineSnapshotLifecycle, 'superseded')->label)->toBe('Superseded')
        ->and(BadgeCatalog::spec(BadgeDomain::RestoreRunStatus, 'partial')->label)->toBe('Applied with follow-up')
        ->and(BadgeCatalog::spec(BadgeDomain::RestoreResultStatus, 'manual_required')->label)->toBe('Manual follow-up needed')
        ->and(BadgeCatalog::spec(BadgeDomain::RestoreCheckSeverity, 'warning')->label)->toBe('Review before running');
});

it('maps operator explanation evaluation and trust badges through centralized taxonomy', function (): void {
    expect(BadgeCatalog::spec(BadgeDomain::OperatorExplanationEvaluationResult, 'suppressed_result')->label)->toBe('Suppressed result')
        ->and(BadgeCatalog::spec(BadgeDomain::OperatorExplanationEvaluationResult, 'unavailable')->label)->toBe('Result unavailable')
        ->and(BadgeCatalog::spec(BadgeDomain::OperatorExplanationTrustworthiness, 'limited_confidence')->label)->toBe('Limited confidence')
        ->and(BadgeCatalog::spec(BadgeDomain::OperatorExplanationTrustworthiness, 'unusable')->label)->toBe('Not usable yet');
});

it('rejects diagnostic warning or danger taxonomy combinations', function (): void {
    expect(fn (): BadgeSpec => new BadgeSpec(
        label: 'Invalid diagnostic warning',
        color: 'warning',
        semanticAxis: OperatorSemanticAxis::EvidenceDepth,
        classification: OperatorStateClassification::Diagnostic,
        nextActionPolicy: OperatorNextActionPolicy::None,
    ))->toThrow(InvalidArgumentException::class);
});

it('rejects primary warning badges without a next-action policy', function (): void {
    expect(fn (): BadgeSpec => new BadgeSpec(
        label: 'Invalid primary warning',
        color: 'warning',
        semanticAxis: OperatorSemanticAxis::ExecutionOutcome,
        classification: OperatorStateClassification::Primary,
        nextActionPolicy: OperatorNextActionPolicy::None,
    ))->toThrow(InvalidArgumentException::class);
});
