<?php

namespace App\Jobs;

use App\Jobs\Middleware\TrackOperationRun;
use App\Models\OperationRun;
use App\Models\ManagedEnvironment;
use App\Services\Directory\EntraGroupSyncService;
use App\Services\Intune\AuditLogger;
use App\Services\OperationRunService;
use App\Support\OperationRunOutcome;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use RuntimeException;

class EntraGroupSyncJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $timeout = 240;

    public bool $failOnTimeout = true;

    public ?OperationRun $operationRun = null;

    public function __construct(
        public int $tenantId,
        public string $selectionKey,
        public ?string $slotKey = null,
        public ?int $runId = null,
        public ?int $providerConnectionId = null,
        ?OperationRun $operationRun = null
    ) {
        $this->operationRun = $operationRun;
    }

    public function middleware(): array
    {
        return [new TrackOperationRun];
    }

    public function handle(EntraGroupSyncService $syncService, AuditLogger $auditLogger): void
    {
        if (! $this->operationRun) {
            $this->fail(new RuntimeException('OperationRun context is required for EntraGroupSyncJob.'));

            return;
        }

        $tenant = ManagedEnvironment::query()->find($this->tenantId);
        if (! $tenant instanceof ManagedEnvironment) {
            throw new RuntimeException('ManagedEnvironment not found.');
        }

        /** @var OperationRunService $opService */
        $opService = app(OperationRunService::class);

        if ($this->operationRun->status === 'queued') {
            $opService->updateRun($this->operationRun, 'running');
        }

        $auditLogger->log(
            tenant: $tenant,
            action: 'directory_groups.sync.started',
            context: [
                'selection_key' => $this->selectionKey,
                'slot_key' => $this->slotKey,
            ],
            actorId: $this->operationRun->user_id,
            status: 'success',
            resourceType: 'operation_run',
            resourceId: (string) $this->operationRun->getKey(),
        );

        $result = $syncService->sync($tenant, $this->selectionKey, $this->providerConnectionId());

        $terminalStatus = 'succeeded';

        if ($result['error_code'] !== null) {
            $terminalStatus = 'failed';
        } elseif ($result['safety_stop_triggered'] === true) {
            $terminalStatus = 'partial';
        }

        $opOutcome = match ($terminalStatus) {
            'succeeded' => OperationRunOutcome::Succeeded->value,
            'partial' => OperationRunOutcome::PartiallySucceeded->value,
            default => OperationRunOutcome::Failed->value,
        };

        $failures = [];
        if (is_string($result['error_code']) && $result['error_code'] !== '') {
            $failures[] = [
                'code' => $result['error_code'],
                'message' => is_string($result['error_summary']) ? $result['error_summary'] : 'Directory groups sync failed.',
            ];
        }

        $opService->updateRun(
            $this->operationRun,
            'completed',
            $opOutcome,
            [
                'total' => (int) $result['items_observed_count'],
                'processed' => (int) $result['items_observed_count'],
                'updated' => (int) $result['items_upserted_count'],
                'failed' => (int) $result['error_count'],
            ],
            $failures,
        );

        $auditLogger->log(
            tenant: $tenant,
            action: $terminalStatus === 'succeeded'
                ? 'directory_groups.sync.succeeded'
                : ($terminalStatus === 'partial'
                    ? 'directory_groups.sync.partial'
                    : 'directory_groups.sync.failed'),
            context: [
                'selection_key' => $this->selectionKey,
                'slot_key' => $this->slotKey,
                'pages_fetched' => $result['pages_fetched'],
                'items_observed_count' => $result['items_observed_count'],
                'items_upserted_count' => $result['items_upserted_count'],
                'error_code' => $result['error_code'],
                'error_category' => $result['error_category'],
            ],
            actorId: $this->operationRun->user_id,
            status: $terminalStatus === 'failed' ? 'failed' : 'success',
            resourceType: 'operation_run',
            resourceId: (string) $this->operationRun->getKey(),
        );
    }

    private function providerConnectionId(): ?int
    {
        if (is_int($this->providerConnectionId) && $this->providerConnectionId > 0) {
            return $this->providerConnectionId;
        }

        $context = is_array($this->operationRun?->context ?? null) ? $this->operationRun->context : [];
        $providerConnectionId = $context['provider_connection_id'] ?? null;

        return is_numeric($providerConnectionId) ? (int) $providerConnectionId : null;
    }
}
