namespace Pivot\Runtime\Swoole;

use Swoole\Http\Server;
use Swoole\Coroutine;
use Pivot\Core\Application;

class SwooleAdapter implements RuntimeAdapterInterface
{
    private Server $server;
    private Application $app;
    private CoroutineContext $context;
    
    public function serve(Application $app, array $config = []): void
    {
        $this->app = $app;
        $this->initializeServer($config);
        $this->configureCoroutines();
        $this->registerEventHandlers();
        $this->server->start();
    }
    
    private function onRequest(\Swoole\Http\Request $request, \Swoole\Http\Response $response): void
    {
        // Criar contexto de corrotina
        $cid = Coroutine::getCid();
        $this->context->enter($cid);
        
        try {
            // Processar request
            $pivotResponse = $this->handleRequest($request);
            $this->sendResponse($response, $pivotResponse);
        } finally {
            $this->context->leave($cid);
        }
    }
}

namespace Pivot\Runtime\Swoole\Coroutine;

class CoroutineContext
{
    private array $contexts = [];
    
    public function enter(int $cid): void
    {
        $this->contexts[$cid] = [
            'request' => null,
            'user' => null,
            'db_transactions' => [],
        ];
    }
    
    public function set(string $key, mixed $value): void
    {
        $cid = Coroutine::getCid();
        $this->contexts[$cid][$key] = $value;
    }
    
    public function get(string $key): mixed
    {
        $cid = Coroutine::getCid();
        return $this->contexts[$cid][$key] ?? null;
    }
    
    public function leave(int $cid): void
    {
        unset($this->contexts[$cid]);
    }
}

namespace Pivot\Runtime\Swoole\WebSocket;

class WebSocketServer
{
    private Server $server;
    private array $connections = [];
    
    public function onOpen(Server $server, Request $request): void
    {
        $this->connections[$request->fd] = [
            'fd' => $request->fd,
            'user' => $this->authenticate($request),
            'subscriptions' => [],
        ];
    }
    
    public function onMessage(Server $server, Frame $frame): void
    {
        $message = json_decode($frame->data, true);
        
        // Processar através do sistema de eventos do Pivot
        $response = $this->app->dispatch(new WebSocketMessage($message));
        
        $server->push($frame->fd, json_encode($response));
    }
}

namespace Pivot\Runtime\Swoole\Worker;

class TaskWorker
{
    public function handle(Server $server, int $taskId, int $reactorId, mixed $data): mixed
    {
        return match($data['type']) {
            'email' => $this->processEmail($data),
            'notification' => $this->processNotification($data),
            'cache_warm' => $this->warmCache($data),
            default => throw new \InvalidArgumentException('Unknown task type'),
        };
    }
    
    public function dispatch(string $type, array $data): void
    {
        $this->server->task([
            'type' => $type,
            'data' => $data,
            'dispatched_at' => microtime(true),
        ]);
    }
}

// config/swoole.php
return [
    'server' => [
        'host' => '0.0.0.0',
        'port' => 9501,
        'mode' => SWOOLE_PROCESS,
        'sock_type' => SWOOLE_SOCK_TCP,
    ],
    
    'settings' => [
        'worker_num' => swoole_cpu_num() * 2,
        'task_worker_num' => swoole_cpu_num(),
        'max_request' => 10000,
        'dispatch_mode' => 3,
        'open_http2_protocol' => true,
        'enable_coroutine' => true,
        'max_coroutine' => 100000,
    ],
    
    'coroutine' => [
        'hook_flags' => SWOOLE_HOOK_ALL,
        'max_concurrency' => 1000,
    ],
    
    'websocket' => [
        'enabled' => true,
        'heartbeat_idle_time' => 600,
        'heartbeat_check_interval' => 60,
    ],
    
    'hot_reload' => [
        'enabled' => env('APP_DEBUG', false),
        'watch_dirs' => [
            base_path('app'),
            base_path('config'),
            base_path('routes'),
        ],
    ],
];