<?php

use App\Filament\Resources\BackupSetResource\Pages\ListBackupSets;
use App\Filament\Resources\PolicyResource\Pages\ListPolicies;
use App\Filament\Resources\PolicyVersionResource\Pages\ListPolicyVersions;
use App\Filament\Resources\RestoreRunResource\Pages\ListRestoreRuns;
use App\Filament\Resources\TenantResource\Pages\ListTenants;
use App\Models\BackupItem;
use App\Models\BackupSet;
use App\Models\Policy;
use App\Models\PolicyVersion;
use App\Models\RestoreRun;
use App\Models\Tenant;
use App\Models\User;
use Filament\Facades\Filament;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Livewire\Livewire;

uses(RefreshDatabase::class);

test('backup set can be archived when unused', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-1',
        'name' => 'Tenant',
    ]);

    $tenant->makeCurrent();

    $backupSet = BackupSet::create([
        'tenant_id' => $tenant->id,
        'name' => 'Set 1',
        'status' => 'completed',
    ]);

    BackupItem::create([
        'tenant_id' => $tenant->id,
        'backup_set_id' => $backupSet->id,
        'policy_id' => null,
        'policy_identifier' => 'policy-1',
        'policy_type' => 'deviceConfiguration',
        'platform' => 'windows',
        'payload' => ['id' => 'policy-1'],
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListBackupSets::class)
        ->callTableAction('archive', $backupSet);

    $this->assertSoftDeleted('backup_sets', ['id' => $backupSet->id]);
    $this->assertSoftDeleted('backup_items', ['backup_set_id' => $backupSet->id]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'backup_set',
        'resource_id' => (string) $backupSet->id,
        'action' => 'backup.deleted',
    ]);
});

test('backup set can be archived when restore runs exist', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-2',
        'name' => 'Tenant 2',
    ]);

    $tenant->makeCurrent();

    $backupSet = BackupSet::create([
        'tenant_id' => $tenant->id,
        'name' => 'Set with restore',
        'status' => 'completed',
    ]);

    $restoreRun = RestoreRun::create([
        'tenant_id' => $tenant->id,
        'backup_set_id' => $backupSet->id,
        'status' => 'completed',
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListBackupSets::class)
        ->callTableAction('archive', $backupSet);

    $this->assertSoftDeleted('backup_sets', ['id' => $backupSet->id]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'backup_set',
        'resource_id' => (string) $backupSet->id,
        'action' => 'backup.deleted',
    ]);
    $this->assertDatabaseHas('restore_runs', ['id' => $restoreRun->id]);
});

test('backup set can be force deleted when trashed and unused', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-force',
        'name' => 'Tenant Force',
    ]);

    $tenant->makeCurrent();

    $backupSet = BackupSet::create([
        'tenant_id' => $tenant->id,
        'name' => 'Set force',
        'status' => 'completed',
    ]);

    BackupItem::create([
        'tenant_id' => $tenant->id,
        'backup_set_id' => $backupSet->id,
        'policy_id' => null,
        'policy_identifier' => 'policy-force',
        'policy_type' => 'deviceConfiguration',
        'platform' => 'windows',
        'payload' => ['id' => 'policy-force'],
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListBackupSets::class)
        ->callTableAction('archive', $backupSet)
        ->set('tableFilters.trashed.value', 1)
        ->callTableAction('forceDelete', $backupSet);

    $this->assertDatabaseMissing('backup_sets', ['id' => $backupSet->id]);
    $this->assertDatabaseMissing('backup_items', ['backup_set_id' => $backupSet->id]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'backup_set',
        'resource_id' => (string) $backupSet->id,
        'action' => 'backup.force_deleted',
    ]);
});

test('backup set can be restored when archived', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-restore-backup-set',
        'name' => 'Tenant Restore Backup Set',
    ]);

    $tenant->makeCurrent();

    $backupSet = BackupSet::create([
        'tenant_id' => $tenant->id,
        'name' => 'Set restore',
        'status' => 'completed',
    ]);

    BackupItem::create([
        'tenant_id' => $tenant->id,
        'backup_set_id' => $backupSet->id,
        'policy_id' => null,
        'policy_identifier' => 'policy-restore',
        'policy_type' => 'deviceConfiguration',
        'platform' => 'windows',
        'payload' => ['id' => 'policy-restore'],
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListBackupSets::class)
        ->callTableAction('archive', $backupSet)
        ->set('tableFilters.trashed.value', 1)
        ->callTableAction('restore', $backupSet);

    $this->assertDatabaseHas('backup_sets', ['id' => $backupSet->id, 'deleted_at' => null]);
    $this->assertDatabaseHas('backup_items', ['backup_set_id' => $backupSet->id, 'deleted_at' => null]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'backup_set',
        'resource_id' => (string) $backupSet->id,
        'action' => 'backup.restored',
    ]);
});

test('restore run can be archived and force deleted', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-restore-run',
        'name' => 'Tenant Restore Run',
    ]);

    $tenant->makeCurrent();

    $backupSet = BackupSet::create([
        'tenant_id' => $tenant->id,
        'name' => 'Set RR',
        'status' => 'completed',
        'item_count' => 1,
    ]);

    $restoreRun = RestoreRun::create([
        'tenant_id' => $tenant->id,
        'backup_set_id' => $backupSet->id,
        'status' => 'completed',
        'is_dry_run' => true,
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListRestoreRuns::class)
        ->callTableAction('archive', $restoreRun)
        ->set('tableFilters.trashed.value', 1)
        ->callTableAction('forceDelete', $restoreRun);

    $this->assertDatabaseMissing('restore_runs', ['id' => $restoreRun->id]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'restore_run',
        'resource_id' => (string) $restoreRun->id,
        'action' => 'restore_run.force_deleted',
    ]);
});

test('restore run can be restored when archived', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-restore-restore-run',
        'name' => 'Tenant Restore Restore Run',
    ]);

    $tenant->makeCurrent();

    $backupSet = BackupSet::create([
        'tenant_id' => $tenant->id,
        'name' => 'Set for restore run restore',
        'status' => 'completed',
        'item_count' => 1,
    ]);

    $restoreRun = RestoreRun::create([
        'tenant_id' => $tenant->id,
        'backup_set_id' => $backupSet->id,
        'status' => 'completed',
        'is_dry_run' => true,
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListRestoreRuns::class)
        ->callTableAction('archive', $restoreRun)
        ->set('tableFilters.trashed.value', 1)
        ->callTableAction('restore', $restoreRun);

    $this->assertDatabaseHas('restore_runs', ['id' => $restoreRun->id, 'deleted_at' => null]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'restore_run',
        'resource_id' => (string) $restoreRun->id,
        'action' => 'restore_run.restored',
    ]);
});

test('policy can be ignored and restored via row actions', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-policy-row-actions',
        'name' => 'Tenant Policy Row Actions',
        'metadata' => [],
    ]);

    $tenant->makeCurrent();

    $policy = Policy::create([
        'tenant_id' => $tenant->id,
        'external_id' => 'policy-row-1',
        'policy_type' => 'deviceConfiguration',
        'display_name' => 'Row Action Policy',
        'platform' => 'windows',
        'last_synced_at' => now(),
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListPolicies::class)
        ->callTableAction('ignore', $policy);

    $policy->refresh();
    expect($policy->ignored_at)->not->toBeNull();

    Livewire::test(ListPolicies::class)
        ->set('tableFilters.visibility.value', 'ignored')
        ->callTableAction('restore', $policy);

    $policy->refresh();
    expect($policy->ignored_at)->toBeNull();
});

test('policy version can be archived with audit log', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-3',
        'name' => 'Tenant 3',
    ]);

    $tenant->makeCurrent();

    $policy = Policy::create([
        'tenant_id' => $tenant->id,
        'external_id' => 'pol-1',
        'policy_type' => 'deviceConfiguration',
        'display_name' => 'Policy',
    ]);

    $version = PolicyVersion::create([
        'tenant_id' => $tenant->id,
        'policy_id' => $policy->id,
        'version_number' => 1,
        'policy_type' => 'deviceConfiguration',
        'snapshot' => ['id' => 'pol-1'],
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListPolicyVersions::class)
        ->callTableAction('archive', $version);

    $this->assertSoftDeleted('policy_versions', ['id' => $version->id]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'policy_version',
        'resource_id' => (string) $version->id,
        'action' => 'policy_version.deleted',
    ]);
});

test('policy version can be force deleted when trashed', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-3b',
        'name' => 'Tenant 3b',
    ]);

    $tenant->makeCurrent();

    $policy = Policy::create([
        'tenant_id' => $tenant->id,
        'external_id' => 'pol-1b',
        'policy_type' => 'deviceConfiguration',
        'display_name' => 'Policy B',
    ]);

    $version = PolicyVersion::create([
        'tenant_id' => $tenant->id,
        'policy_id' => $policy->id,
        'version_number' => 1,
        'policy_type' => 'deviceConfiguration',
        'snapshot' => ['id' => 'pol-1b'],
    ]);

    $user = User::factory()->create();
    $this->actingAs($user);
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($tenant, true);

    Livewire::test(ListPolicyVersions::class)
        ->callTableAction('archive', $version)
        ->set('tableFilters.trashed.value', 1)
        ->callTableAction('forceDelete', $version);

    $this->assertDatabaseMissing('policy_versions', ['id' => $version->id]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'policy_version',
        'resource_id' => (string) $version->id,
        'action' => 'policy_version.force_deleted',
    ]);
});

test('tenant can be archived and hidden from default lists', function () {
    $tenant = Tenant::factory()->create([
        'tenant_id' => 'tenant-4',
        'name' => 'Tenant 4',
        'status' => 'active',
    ]);

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

    Livewire::test(ListTenants::class)
        ->callTableAction('archive', $tenant);

    expect(Tenant::count())->toBe(0);

    $this->assertSoftDeleted('tenants', ['id' => $tenant->id]);
    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'tenant',
        'resource_id' => (string) $tenant->id,
        'action' => 'tenant.archived',
    ]);
});

test('tenant must be trashed before force delete and removes permanently', function () {
    $tenant = Tenant::create([
        'tenant_id' => 'tenant-5',
        'name' => 'Tenant 5',
    ]);

    $tenant->delete();
    $tenant->forceDelete();

    $this->assertDatabaseMissing('tenants', ['id' => $tenant->id]);
});

test('tenant table archive filter toggles active and archived tenants', function () {
    $active = Tenant::factory()->create([
        'tenant_id' => 'tenant-active',
        'name' => 'Active Tenant',
        'status' => 'active',
    ]);

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

    $archived = Tenant::factory()->create([
        'tenant_id' => 'tenant-archived',
        'name' => 'Archived Tenant',
        'status' => 'active',
        'workspace_id' => $active->workspace_id,
    ]);

    $archived->delete();

    $user->tenants()->syncWithoutDetaching([
        $archived->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($active, true);

    $this->withSession([
        \App\Support\Workspaces\WorkspaceContext::SESSION_KEY => (int) $active->workspace_id,
    ]);
    session([
        \App\Support\Workspaces\WorkspaceContext::SESSION_KEY => (int) $active->workspace_id,
    ]);

    $component = Livewire::actingAs($user)
        ->test(ListTenants::class)
        ->filterTable('trashed', true)
        ->assertSee($active->name)
        ->assertSee($archived->name);

    $component
        ->filterTable('trashed', null)
        ->assertSee($active->name)
        ->assertDontSee($archived->name);

    $component
        ->filterTable('trashed', false)
        ->assertSee($archived->name)
        ->assertDontSee($active->name);
});

test('archived tenant can be restored from the table', function () {
    $contextTenant = Tenant::factory()->create([
        'tenant_id' => 'tenant-restore-context',
        'name' => 'Restore Context Tenant',
        'status' => 'active',
    ]);

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

    $tenant = Tenant::factory()->create([
        'tenant_id' => 'tenant-restore',
        'name' => 'Restore Tenant',
        'status' => 'active',
        'workspace_id' => $contextTenant->workspace_id,
    ]);

    $tenant->delete();
    $user->tenants()->syncWithoutDetaching([
        $tenant->getKey() => ['role' => 'owner'],
    ]);
    Filament::setTenant($contextTenant, true);

    $this->withSession([
        \App\Support\Workspaces\WorkspaceContext::SESSION_KEY => (int) $contextTenant->workspace_id,
    ]);
    session([
        \App\Support\Workspaces\WorkspaceContext::SESSION_KEY => (int) $contextTenant->workspace_id,
    ]);

    Livewire::actingAs($user)
        ->test(ListTenants::class)
        ->filterTable('trashed', false)
        ->callTableAction('restore', $tenant);

    $this->assertDatabaseHas('tenants', [
        'id' => $tenant->id,
        'deleted_at' => null,
        'status' => 'active',
    ]);

    $this->assertDatabaseHas('audit_logs', [
        'resource_type' => 'tenant',
        'resource_id' => (string) $tenant->id,
        'action' => 'tenant.restored',
    ]);
});
