<?php

declare(strict_types=1);

namespace KTXT\Unit\Module;

use KTXC\Console\Firewall\FirewallMaintenanceCommand;
use KTXC\Console\Firewall\FirewallSetupCommand;
use KTXC\Console\Event\EventsDebugCommand;
use KTXC\Module\Module;
use KTXC\Service\FirewallService;
use KTXC\Service\SystemFirewallRuleService;
use KTXC\Service\SystemFirewallLogService;
use KTXC\Service\TenantFirewallLogService;
use KTXC\Service\TenantFirewallStatusService;
use KTXC\Service\SystemFirewallStatusService;
use KTXC\Service\TenantFirewallRuleService;
use KTXC\Event\EventListenerRegistry;
use KTXC\Security\Event\AccessDeniedEvent;
use KTXC\Security\Event\AuthenticationFailedEvent;
use KTXC\Security\Event\BruteForceDetectedEvent;
use KTXC\Security\Event\SecurityEvent;
use KTXF\Event\DeliveryMode;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;

final class CoreModuleTest extends TestCase
{
    #[Test]
    #[TestDox('Core boot registers owned listeners without resolving services')]
    public function registersListeners(): void
    {
        $registry = new EventListenerRegistry();
        $module = new Module($registry);

        $module->boot();
        $definitions = $registry->definitions();

        self::assertCount(12, $definitions);
        self::assertSame(['core'], array_values(array_unique(array_column($definitions, 'module'))));
        self::assertSame(
            FirewallService::class,
            $registry->listeners(AuthenticationFailedEvent::class, DeliveryMode::Immediate)[0]->service,
        );
        self::assertSame([], $registry->listeners(AuthenticationFailedEvent::class, DeliveryMode::Deferred));
        foreach ([
            AccessDeniedEvent::class,
            BruteForceDetectedEvent::class,
            SecurityEvent::RATE_LIMIT_EXCEEDED,
            SecurityEvent::SUSPICIOUS_ACTIVITY,
            SecurityEvent::FIREWALL_RULE_CREATED,
            SecurityEvent::FIREWALL_RULE_EXTENDED,
            SecurityEvent::FIREWALL_RULE_DISABLED,
            SecurityEvent::FIREWALL_RULE_ENABLED,
            SecurityEvent::FIREWALL_RULE_REMOVED,
            SecurityEvent::FIREWALL_SETTINGS_UPDATED,
        ] as $event) {
            $listeners = $registry->listeners($event, DeliveryMode::Deferred);
            self::assertCount(1, $listeners);
            self::assertSame(FirewallService::class, $listeners[0]->service);
            self::assertSame('logSecurityEvent', $listeners[0]->method);
        }
        self::assertFalse($registry->frozen());
    }

    #[Test]
    #[TestDox('Core exposes the event registry debug command')]
    public function exposesDebugCommand(): void
    {
        $module = new Module(new EventListenerRegistry());

        self::assertContains(EventsDebugCommand::class, $module->registerCI());
        self::assertContains(FirewallSetupCommand::class, $module->registerCI());
        self::assertContains(FirewallMaintenanceCommand::class, $module->registerCI());
    }

    #[Test]
    #[TestDox('Core registers dedicated system firewall permissions')]
    public function registersSystemFirewallPermissions(): void
    {
        $permissions = (new Module(new EventListenerRegistry()))->permissions();

        self::assertArrayHasKey(SystemFirewallRuleService::PERMISSION_READ, $permissions);
        self::assertArrayHasKey(SystemFirewallRuleService::PERMISSION_MANAGE, $permissions);
        self::assertArrayHasKey(TenantFirewallRuleService::PERMISSION_READ, $permissions);
        self::assertArrayHasKey(TenantFirewallRuleService::PERMISSION_MANAGE, $permissions);
        self::assertArrayHasKey(TenantFirewallLogService::PERMISSION_READ, $permissions);
        self::assertArrayHasKey(SystemFirewallLogService::PERMISSION_READ, $permissions);
        self::assertArrayHasKey(TenantFirewallStatusService::PERMISSION_SETTINGS_READ, $permissions);
        self::assertArrayHasKey(TenantFirewallStatusService::PERMISSION_SETTINGS_MANAGE, $permissions);
        self::assertArrayHasKey(SystemFirewallStatusService::PERMISSION_MAINTENANCE_READ, $permissions);
        self::assertArrayHasKey(SystemFirewallStatusService::PERMISSION_SETTINGS_MANAGE, $permissions);
    }
}