namespace Pivot\Runtime\RoadRunner;

use Spiral\RoadRunner\Worker;
use Spiral\RoadRunner\Http\PSR7Worker;
use Pivot\Core\Application;
use Nyholm\Psr7\Factory\Psr17Factory;

class RoadRunnerAdapter implements RuntimeAdapterInterface
{
    private PSR7Worker $worker;
    private Application $app;
    private WorkerManager $manager;
    
    public function serve(Application $app, array $config = []): void
    {
        $this->app = $app;
        $this->initializeWorker();
        $this->runWorkerLoop();
    }
    
    private function initializeWorker(): void
    {
        $worker = Worker::create();
        $factory = new Psr17Factory();
        
        $this->worker = new PSR7Worker($worker, $factory, $factory, $factory);
        $this->manager = new WorkerManager($worker);
    }
    
    private function runWorkerLoop(): void
    {
        while ($request = $this->worker->waitRequest()) {
            try {
                // Reset application state
                $this->manager->beforeRequest();
                
                // Process request
                $response = $this->processRequest($request);
                
                // Send response
                $this->worker->respond($response);
                
                // Cleanup
                $this->manager->afterRequest();
                
                // Check if worker should restart
                if ($this->manager->shouldRestart()) {
                    break;
                }
            } catch (\Throwable $e) {
                $this->worker->getWorker()->error((string)$e);
            }
        }
    }
}

namespace Pivot\Runtime\RoadRunner\Worker;

class WorkerManager
{
    private int $requestCount = 0;
    private float $startTime;
    private array $metrics = [];
    
    public function beforeRequest(): void
    {
        $this->requestCount++;
        $this->captureMemoryUsage();
        $this->resetGlobalState();
    }
    
    public function afterRequest(): void
    {
        $this->collectGarbage();
        $this->checkMemoryLimits();
        $this->updateMetrics();
    }
    
    public function shouldRestart(): bool
    {
        // Restart after X requests
        if ($this->requestCount >= config('roadrunner.max_requests', 10000)) {
            return true;
        }
        
        // Restart on memory threshold
        if (memory_get_usage(true) > config('roadrunner.memory_limit', 128 * 1024 * 1024)) {
            return true;
        }
        
        // Restart after TTL
        if (time() - $this->startTime > config('roadrunner.ttl', 3600)) {
            return true;
        }
        
        return false;
    }
}

namespace Pivot\Runtime\RoadRunner\Plugins;

use Spiral\RoadRunner\Jobs\JobsInterface;
use Spiral\RoadRunner\Jobs\Queue;

class JobsPlugin
{
    private JobsInterface $jobs;
    
    public function dispatch(string $queue, array $payload): string
    {
        $queue = $this->jobs->connect($queue);
        
        $task = $queue->create(
            class: PivotJobHandler::class,
            payload: $payload,
            options: [
                'delay' => 0,
                'priority' => 10,
            ]
        );
        
        return $queue->dispatch($task);
    }
    
    public function consume(string $queue, callable $handler): void
    {
        $consumer = $this->jobs->consume($queue);
        
        while ($task = $consumer->waitTask()) {
            try {
                $result = $handler($task->payload);
                $task->complete($result);
            } catch (\Throwable $e) {
                $task->fail($e);
            }
        }
    }
}

namespace Pivot\Runtime\RoadRunner\Plugins;

use Spiral\RoadRunner\KeyValue\StorageInterface;

class KVPlugin
{
    private StorageInterface $storage;
    
    public function set(string $key, mixed $value, int $ttl = 0): void
    {
        $this->storage->set($key, serialize($value), $ttl);
    }
    
    public function get(string $key): mixed
    {
        $value = $this->storage->get($key);
        return $value ? unserialize($value) : null;
    }
    
    public function mget(array $keys): array
    {
        return array_map('unserialize', $this->storage->mGet($keys));
    }
}