<?php

use App\Filament\Resources\InventoryItemResource\Pages\ListInventoryItems;
use App\Jobs\RunInventorySyncJob;
use App\Livewire\BulkOperationProgress;
use App\Models\OperationRun;
use App\Models\ManagedEnvironment;
use App\Services\Inventory\InventorySyncService;
use App\Services\OperationRunService;
use App\Support\OpsUx\OpsUxBrowserEvents;
use Filament\Facades\Filament;
use Filament\Forms\Components\Field;
use Filament\Schemas\Components\Text;
use Illuminate\Support\Facades\Queue;
use Livewire\Livewire;

it('dispatches inventory sync and creates observable run records', function () {
    Queue::fake();

    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

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

    $sync = app(InventorySyncService::class);
    $allTypes = $sync->defaultSelectionPayload()['policy_types'];

    Livewire::test(ListInventoryItems::class)
        ->callAction('run_inventory_sync', data: ['policy_types' => $allTypes])
        ->assertDispatchedTo(BulkOperationProgress::class, OpsUxBrowserEvents::RunEnqueued, tenantId: (int) $tenant->getKey());

    Queue::assertPushed(RunInventorySyncJob::class);

    $opRun = OperationRun::query()
        ->where('managed_environment_id', $tenant->id)
        ->where('user_id', $user->id)
        ->where('type', 'inventory.sync')
        ->latest('id')
        ->first();

    expect($opRun)->not->toBeNull();
    expect($opRun->status)->toBe('queued');

    $context = is_array($opRun->context) ? $opRun->context : [];
    expect($context['selection_hash'] ?? null)->not->toBeNull();
});

it('dispatches inventory sync for selected policy types', function () {
    Queue::fake();

    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

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

    $sync = app(InventorySyncService::class);
    $allTypes = $sync->defaultSelectionPayload()['policy_types'];
    $selectedTypes = array_slice($allTypes, 0, min(2, count($allTypes)));

    Livewire::test(ListInventoryItems::class)
        ->mountAction('run_inventory_sync')
        ->set('mountedActions.0.data.policy_types', $selectedTypes)
        ->assertActionDataSet(['policy_types' => $selectedTypes])
        ->callMountedAction()
        ->assertHasNoActionErrors();

    Queue::assertPushed(RunInventorySyncJob::class);

    $opRun = OperationRun::query()
        ->where('managed_environment_id', $tenant->id)
        ->where('type', 'inventory.sync')
        ->latest('id')
        ->first();

    expect($opRun)->not->toBeNull();
    $context = is_array($opRun->context) ? $opRun->context : [];
    expect($context['policy_types'] ?? [])->toEqualCanonicalizing($selectedTypes);
});

it('persists include dependencies toggle into the run selection payload', function () {
    Queue::fake();

    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

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

    $sync = app(InventorySyncService::class);
    $allTypes = $sync->defaultSelectionPayload()['policy_types'];
    $selectedTypes = array_slice($allTypes, 0, min(2, count($allTypes)));

    Livewire::test(ListInventoryItems::class)
        ->callAction('run_inventory_sync', data: [
            'policy_types' => $selectedTypes,
            'include_dependencies' => false,
        ])
        ->assertHasNoActionErrors();

    $opRun = OperationRun::query()
        ->where('managed_environment_id', $tenant->id)
        ->where('type', 'inventory.sync')
        ->latest('id')
        ->first();

    expect($opRun)->not->toBeNull();
    $context = is_array($opRun->context) ? $opRun->context : [];
    expect((bool) ($context['include_dependencies'] ?? true))->toBeFalse();
});

it('defaults include foundations toggle to true and persists it into the run selection payload', function () {
    Queue::fake();

    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

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

    $sync = app(InventorySyncService::class);
    $allTypes = $sync->defaultSelectionPayload()['policy_types'];
    $selectedTypes = array_slice($allTypes, 0, min(2, count($allTypes)));

    Livewire::test(ListInventoryItems::class)
        ->mountAction('run_inventory_sync')
        ->set('mountedActions.0.data.policy_types', $selectedTypes)
        ->assertActionDataSet(['include_foundations' => true])
        ->callMountedAction()
        ->assertHasNoActionErrors();

    $opRun = OperationRun::query()
        ->where('managed_environment_id', $tenant->id)
        ->where('type', 'inventory.sync')
        ->latest('id')
        ->first();

    expect($opRun)->not->toBeNull();
    $context = is_array($opRun->context) ? $opRun->context : [];
    expect((bool) ($context['include_foundations'] ?? false))->toBeTrue();
});

it('describes RBAC items in the include foundations helper text', function () {
    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

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

    $component = Livewire::test(ListInventoryItems::class)
        ->mountAction('run_inventory_sync');

    $method = new ReflectionMethod($component->instance(), 'getMountedActionForm');
    $method->setAccessible(true);

    $form = $method->invoke($component->instance());

    $field = collect($form?->getFlatFields(withHidden: true) ?? [])
        ->first(fn (Field $field): bool => $field->getName() === 'include_foundations');

    $helperText = collect($field?->getChildSchema(Field::BELOW_CONTENT_SCHEMA_KEY)?->getComponents() ?? [])
        ->filter(fn (mixed $component): bool => $component instanceof Text)
        ->map(fn (Text $component): string => (string) $component->getContent())
        ->implode(' ');

    expect($helperText)->toBe('Include scope tags, assignment filters, notification templates, and Intune RBAC role definitions and assignments.');
});

it('persists include foundations toggle into the run selection payload', function () {
    Queue::fake();

    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);

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

    $sync = app(InventorySyncService::class);
    $allTypes = $sync->defaultSelectionPayload()['policy_types'];
    $selectedTypes = array_slice($allTypes, 0, min(2, count($allTypes)));

    Livewire::test(ListInventoryItems::class)
        ->callAction('run_inventory_sync', data: [
            'policy_types' => $selectedTypes,
            'include_foundations' => false,
        ])
        ->assertHasNoActionErrors();

    $opRun = OperationRun::query()
        ->where('managed_environment_id', $tenant->id)
        ->where('type', 'inventory.sync')
        ->latest('id')
        ->first();

    expect($opRun)->not->toBeNull();
    $context = is_array($opRun->context) ? $opRun->context : [];
    expect((bool) ($context['include_foundations'] ?? true))->toBeFalse();
});

it('rejects cross-tenant initiation attempts (403) with no side effects', function () {
    Queue::fake();

    [$user, $tenantA] = createUserWithTenant(role: 'owner');
    $tenantB = ManagedEnvironment::factory()->create();

    $this->actingAs($user);
    Filament::setTenant($tenantA, true);

    $sync = app(InventorySyncService::class);
    $allTypes = $sync->defaultSelectionPayload()['policy_types'];

    Livewire::test(ListInventoryItems::class)
        ->callAction('run_inventory_sync', data: ['managed_environment_id' => $tenantB->getKey(), 'policy_types' => $allTypes])
        ->assertSuccessful();

    Queue::assertNothingPushed();

    expect(OperationRun::query()->where('managed_environment_id', $tenantB->id)->where('type', 'inventory.sync')->exists())->toBeFalse();
    expect(OperationRun::query()->where('managed_environment_id', $tenantB->id)->exists())->toBeFalse();
});

it('blocks dispatch when a matching run is already pending or running', function () {
    Queue::fake();

    [$user, $tenant] = createUserWithTenant(role: 'owner');
    $this->actingAs($user);
    Filament::setTenant($tenant, true);

    $sync = app(InventorySyncService::class);
    $selectionPayload = $sync->defaultSelectionPayload();
    $computed = $sync->normalizeAndHashSelection($selectionPayload);

    $opService = app(OperationRunService::class);
    $existing = $opService->ensureRunWithIdentity(
        tenant: $tenant,
        type: 'inventory.sync',
        identityInputs: [
            'selection_hash' => $computed['selection_hash'],
        ],
        context: array_merge($computed['selection'], [
            'selection_hash' => $computed['selection_hash'],
        ]),
        initiator: $user,
    );

    $existing->forceFill([
        'status' => 'running',
        'started_at' => now(),
    ])->save();

    Livewire::test(ListInventoryItems::class)
        ->callAction('run_inventory_sync', data: ['policy_types' => $computed['selection']['policy_types']]);

    Queue::assertNothingPushed();
    expect(OperationRun::query()->where('managed_environment_id', $tenant->id)->where('type', 'inventory.sync')->count())->toBe(1);
});

it('disables inventory sync start action for readonly users', function () {
    Queue::fake();

    [$user, $tenant] = createUserWithTenant(role: 'readonly');
    $this->actingAs($user);
    Filament::setTenant($tenant, true);

    Livewire::test(ListInventoryItems::class)
        ->assertActionVisible('run_inventory_sync')
        ->assertActionDisabled('run_inventory_sync');

    Queue::assertNothingPushed();
    expect(OperationRun::query()->where('managed_environment_id', $tenant->id)->where('type', 'inventory.sync')->exists())->toBeFalse();
});
