<?php

use App\Models\OperationRun;
use App\Models\PlatformUser;
use App\Notifications\OperationRunCompleted;
use App\Notifications\OperationRunQueued;
use App\Services\OperationRunService;
use App\Support\Baselines\BaselineReasonCodes;
use App\Support\OperationRunLinks;
use App\Support\Auth\PlatformCapabilities;
use App\Support\System\SystemOperationRunLinks;
use Filament\Facades\Filament;
use Filament\Notifications\Notification as FilamentNotification;

if (! function_exists('spec230ExpectedNotificationIcon')) {
    function spec230ExpectedNotificationIcon(string $status): string
    {
        return (string) data_get(
            FilamentNotification::make()->status($status)->getDatabaseMessage(),
            'icon',
            '',
        );
    }
}

it('emits a queued notification after successful dispatch (initiator only) with view link', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $tenant->makeCurrent();
    Filament::setTenant($tenant, true);

    $service = app(OperationRunService::class);
    $run = $service->ensureRun(
        tenant: $tenant,
        type: 'policy.sync',
        inputs: ['scope' => 'all'],
        initiator: $user,
    );

    $service->dispatchOrFail($run, function (): void {
        // no-op (dispatch succeeded)
    }, emitQueuedNotification: true);

    $this->assertDatabaseHas('notifications', [
        'notifiable_id' => $user->getKey(),
        'notifiable_type' => $user->getMorphClass(),
        'type' => OperationRunQueued::class,
        'data->format' => 'filament',
        'data->title' => 'Policy sync queued',
    ]);

    $notification = $user->notifications()->latest('id')->first();
    expect($notification)->not->toBeNull();
    expect($notification->data['body'] ?? null)->toBe('Queued for execution. Open the operation for progress and next steps.');
    expect(data_get($notification->data, 'status'))->toBe('info');
    expect(data_get($notification->data, 'icon'))->toBe(spec230ExpectedNotificationIcon('info'));
    expect(data_get($notification->data, 'actions'))->toHaveCount(1);
    expect(data_get($notification->data, 'actions.0.label'))->toBe(OperationRunLinks::openLabel());
    expect($notification->data['actions'][0]['url'] ?? null)
        ->toBe(OperationRunLinks::view($run, $tenant));
    expect(data_get($notification->data, 'actions.0.target'))->toBe('admin_operation_run');
    expect(array_values(data_get($notification->data, 'supporting_lines', [])))->toBe([]);

    $this->get(data_get($notification->data, 'actions.0.url'))->assertSuccessful();
});

it('does not emit queued notifications for runs without an initiator', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $tenant->makeCurrent();
    Filament::setTenant($tenant, true);

    $service = app(OperationRunService::class);

    $run = $service->ensureRun(
        tenant: $tenant,
        type: 'policy.sync',
        inputs: ['scope' => 'all'],
        initiator: null,
    );

    $service->dispatchOrFail($run, function (): void {
        // no-op
    }, emitQueuedNotification: true);

    expect($user->notifications()->count())->toBe(0);
});

it('uses a tenantless view link for managed environment onboarding wizard runs', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $run = OperationRun::factory()->create([
        'managed_environment_id' => $tenant->getKey(),
        'user_id' => $user->getKey(),
        'initiator_name' => $user->name,
        'type' => 'provider.connection.check',
        'status' => 'queued',
        'outcome' => 'pending',
        'context' => [
            'wizard' => [
                'flow' => 'managed_environment_onboarding',
                'step' => 'verification',
            ],
        ],
    ]);

    $user->notify(new OperationRunQueued($run));

    $notification = $user->notifications()->latest('id')->first();
    expect($notification)->not->toBeNull();
    expect($notification->data['body'] ?? null)->toBe('Queued for execution. Open the operation for progress and next steps.');
    expect(data_get($notification->data, 'status'))->toBe('info');
    expect(data_get($notification->data, 'icon'))->toBe(spec230ExpectedNotificationIcon('info'));
    expect($notification->data['actions'][0]['url'] ?? null)
        ->toBe(OperationRunLinks::tenantlessView($run));
    expect(data_get($notification->data, 'actions.0.target'))->toBe('tenantless_operation_run');
});

it('uses a tenantless view link for queued tenantless runs', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $run = OperationRun::factory()->create([
        'workspace_id' => (int) $tenant->workspace_id,
        'managed_environment_id' => null,
        'user_id' => (int) $user->getKey(),
        'initiator_name' => $user->name,
        'type' => 'provider.connection.check',
        'status' => 'queued',
        'outcome' => 'pending',
        'context' => [],
    ]);

    $user->notify(new OperationRunQueued($run));

    $notification = $user->notifications()->latest('id')->first();
    expect($notification)->not->toBeNull()
        ->and(data_get($notification?->data, 'actions.0.url'))->toBe(OperationRunLinks::tenantlessView($run))
        ->and(data_get($notification?->data, 'actions.0.target'))->toBe('tenantless_operation_run');

    $this->get(data_get($notification?->data, 'actions.0.url'))->assertSuccessful();
});

it('emits a terminal notification when an operation run transitions to completed', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $tenant->makeCurrent();
    Filament::setTenant($tenant, true);

    $run = OperationRun::factory()->create([
        'managed_environment_id' => $tenant->getKey(),
        'user_id' => $user->getKey(),
        'initiator_name' => $user->name,
        'type' => 'inventory_sync',
        'status' => 'queued',
        'outcome' => 'pending',
        'context' => ['policy_types' => ['deviceConfiguration']],
    ]);

    $service = app(OperationRunService::class);

    $service->updateRun(
        $run,
        status: 'completed',
        outcome: 'succeeded',
        summaryCounts: ['total' => 1],
        failures: [],
    );

    $this->assertDatabaseHas('notifications', [
        'notifiable_id' => $user->getKey(),
        'notifiable_type' => $user->getMorphClass(),
        'type' => OperationRunCompleted::class,
        'data->format' => 'filament',
        'data->title' => 'Inventory sync completed successfully',
    ]);

    $notification = $user->notifications()->latest('id')->first();
    expect($notification)->not->toBeNull();
    expect($notification->data['body'] ?? null)->toContain('Completed successfully.');
    expect($notification->data['body'] ?? null)->toContain('No action needed.');
    expect(data_get($notification->data, 'status'))->toBe('success');
    expect(data_get($notification->data, 'icon'))->toBe(spec230ExpectedNotificationIcon('success'));
    expect(data_get($notification->data, 'actions'))->toHaveCount(1);
    expect(array_values(data_get($notification->data, 'supporting_lines', [])))->toContain('No action needed.', 'Total: 1');
    expect($notification->data['actions'][0]['url'] ?? null)
        ->toBe(OperationRunLinks::view($run, $tenant));
    expect(data_get($notification->data, 'actions.0.target'))->toBe('admin_operation_run');

    $this->get(data_get($notification->data, 'actions.0.url'))->assertSuccessful();
});

it('uses a tenantless view link for completed tenantless runs', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $run = OperationRun::factory()->create([
        'workspace_id' => (int) $tenant->workspace_id,
        'managed_environment_id' => null,
        'user_id' => (int) $user->getKey(),
        'initiator_name' => $user->name,
        'type' => 'provider.connection.check',
        'status' => 'queued',
        'outcome' => 'pending',
    ]);

    app(OperationRunService::class)->updateRun(
        $run,
        status: 'completed',
        outcome: 'blocked',
        failures: [[
            'code' => 'operation.blocked',
            'reason_code' => 'execution_prerequisite_invalid',
            'message' => 'Operation blocked because the queued execution prerequisites are no longer satisfied.',
        ]],
    );

    $notification = $user->notifications()->latest('id')->first();

    expect($notification)->not->toBeNull()
        ->and(data_get($notification?->data, 'reason_translation.operator_label'))->toBe('Execution prerequisite changed')
        ->and(data_get($notification?->data, 'diagnostic_reason_code'))->toBe('execution_prerequisite_invalid')
        ->and($notification->data['body'] ?? null)->toContain('Execution prerequisite changed')
        ->and($notification->data['body'] ?? null)->toContain('queued execution prerequisites are no longer satisfied')
        ->and($notification->data['body'] ?? null)->not->toContain('execution_prerequisite_invalid')
        ->and($notification->data['actions'][0]['url'] ?? null)->toBe(OperationRunLinks::tenantlessView($run))
        ->and(data_get($notification?->data, 'actions.0.target'))->toBe('tenantless_operation_run');

    $this->get(data_get($notification?->data, 'actions.0.url'))->assertSuccessful();
});

it('includes baseline truth status in blocked baseline-capture terminal notifications', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $tenant->makeCurrent();
    Filament::setTenant($tenant, true);

    $run = OperationRun::factory()->create([
        'managed_environment_id' => (int) $tenant->getKey(),
        'workspace_id' => (int) $tenant->workspace_id,
        'user_id' => (int) $user->getKey(),
        'initiator_name' => $user->name,
        'type' => 'baseline_capture',
        'status' => 'queued',
        'outcome' => 'pending',
        'context' => [
            'baseline_capture' => [
                'current_baseline_changed' => false,
                'previous_current_snapshot_exists' => true,
            ],
        ],
    ]);

    app(OperationRunService::class)->finalizeBlockedRun(
        run: $run,
        reasonCode: BaselineReasonCodes::CAPTURE_INVENTORY_FAILED,
        message: 'Capture blocked because the latest inventory sync failed.',
    );

    $notification = $user->notifications()->latest('id')->first();

    expect($notification)->not->toBeNull()
        ->and(data_get($notification?->data, 'baseline_truth_changed'))->toBeFalse()
        ->and(data_get($notification?->data, 'reason_translation.operator_label'))->toBe('Latest inventory sync failed')
        ->and(data_get($notification?->data, 'diagnostic_reason_code'))->toBe(BaselineReasonCodes::CAPTURE_INVENTORY_FAILED)
        ->and(array_values(data_get($notification?->data, 'supporting_lines', [])))->toContain('Current baseline truth was unchanged.');
});

it('does not emit terminal notifications for initiator-null baseline-capture runs', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $tenant->makeCurrent();
    Filament::setTenant($tenant, true);

    $run = OperationRun::factory()->create([
        'managed_environment_id' => (int) $tenant->getKey(),
        'workspace_id' => (int) $tenant->workspace_id,
        'user_id' => null,
        'initiator_name' => 'System',
        'type' => 'baseline_capture',
        'status' => 'queued',
        'outcome' => 'pending',
        'context' => [
            'baseline_capture' => [
                'current_baseline_changed' => false,
            ],
        ],
    ]);

    app(OperationRunService::class)->finalizeBlockedRun(
        run: $run,
        reasonCode: BaselineReasonCodes::CAPTURE_ZERO_SUBJECTS,
        message: 'Capture completed without governed subjects in scope.',
    );

    expect($user->notifications()->count())->toBe(0);
});

it('uses the system operation route for completed notifications delivered to platform users', function (): void {
    $platformUser = PlatformUser::factory()->create([
        'capabilities' => [
            PlatformCapabilities::ACCESS_SYSTEM_PANEL,
            PlatformCapabilities::OPERATIONS_VIEW,
        ],
        'is_active' => true,
    ]);

    $run = OperationRun::factory()->create([
        'managed_environment_id' => null,
        'type' => 'inventory_sync',
        'status' => 'completed',
        'outcome' => 'succeeded',
    ]);

    $platformUser->notify(new OperationRunCompleted($run));

    $notification = $platformUser->notifications()->latest('id')->first();

    expect($notification)->not->toBeNull()
        ->and(data_get($notification?->data, 'status'))->toBe('success')
        ->and(data_get($notification?->data, 'icon'))->toBe(spec230ExpectedNotificationIcon('success'))
        ->and(data_get($notification?->data, 'actions.0.label'))->toBe(OperationRunLinks::openLabel())
        ->and(data_get($notification?->data, 'actions.0.url'))->toBe(SystemOperationRunLinks::view($run))
        ->and(data_get($notification?->data, 'actions.0.target'))->toBe('system_operation_run');

    $this->actingAs($platformUser, 'platform')
        ->get(SystemOperationRunLinks::view($run))
        ->assertSuccessful();
});

it('renders partial backup-set update notifications with RBAC foundation summary counts', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $tenant->makeCurrent();
    Filament::setTenant($tenant, true);

    $run = OperationRun::factory()->create([
        'managed_environment_id' => $tenant->getKey(),
        'user_id' => $user->getKey(),
        'initiator_name' => $user->name,
        'type' => 'backup_set.update',
        'status' => 'queued',
        'outcome' => 'pending',
        'context' => [
            'backup_set_id' => 42,
            'options' => ['include_foundations' => true],
        ],
    ]);

    $service = app(OperationRunService::class);

    $service->updateRun(
        $run,
        status: 'completed',
        outcome: 'partially_succeeded',
        summaryCounts: [
            'total' => 3,
            'processed' => 3,
            'succeeded' => 2,
            'failed' => 1,
            'items' => 3,
            'created' => 2,
        ],
        failures: [[
            'code' => 'foundation.capture_failed',
            'message' => 'DeviceManagementRBAC.Read.All is missing.',
        ]],
    );

    $notification = $user->notifications()->latest('id')->first();

    expect($notification)->not->toBeNull();
    expect($notification->data['title'] ?? null)->toBe('Backup set update needs follow-up');
    expect($notification->data['body'] ?? null)->toContain('Completed with follow-up.');
    expect($notification->data['body'] ?? null)->toContain('Review the affected items before rerunning.');
    expect($notification->data['body'] ?? null)->toContain('Total: 3');
    expect($notification->data['body'] ?? null)->toContain('Affected items: 3');
    expect($notification->data['actions'][0]['url'] ?? null)
        ->toBe(OperationRunLinks::view($run, $tenant));
});

it('marks a run failed if dispatch throws synchronously', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $tenant->makeCurrent();
    Filament::setTenant($tenant, true);

    $service = app(OperationRunService::class);

    $run = $service->ensureRun(
        tenant: $tenant,
        type: 'policy.sync',
        inputs: ['scope' => 'all'],
        initiator: $user,
    );

    expect(fn () => $service->dispatchOrFail($run, function (): void {
        throw new RuntimeException('Queue misconfigured');
    }))
        ->toThrow(RuntimeException::class);

    $run->refresh();
    expect($run->status)->toBe('completed');
    expect($run->outcome)->toBe('failed');
});

it('renders reconciled terminal notifications with operator-safe lifecycle copy', function (): void {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

    $run = OperationRun::factory()->create([
        'managed_environment_id' => (int) $tenant->getKey(),
        'workspace_id' => (int) $tenant->workspace_id,
        'user_id' => (int) $user->getKey(),
        'initiator_name' => $user->name,
        'type' => 'restore.execute',
        'status' => 'queued',
        'outcome' => 'pending',
    ]);

    app(OperationRunService::class)->forceFailNonTerminalRun(
        run: $run,
        reasonCode: 'run.infrastructure_timeout_or_abandonment',
        message: 'Queue infrastructure ended the job before normal completion could update the run.',
        source: 'failed_callback',
        evidence: ['exception_class' => 'TimeoutExceededException'],
    );

    $notification = $user->notifications()->latest('id')->first();

    expect($notification)->not->toBeNull()
        ->and((string) data_get($notification?->data, 'title'))->toContain('was automatically reconciled')
        ->and((string) data_get($notification?->data, 'body'))->toContain('Infrastructure ended the run')
        ->and((string) data_get($notification?->data, 'body'))->toContain('Review worker health and logs before retrying this operation')
        ->and(data_get($notification?->data, 'diagnostic_reason_code'))->toBe('run.infrastructure_timeout_or_abandonment');
});
