<?php

namespace App\Jobs;

use App\Jobs\Middleware\TrackOperationRun;
use App\Models\OperationRun;
use App\Models\RestoreRun;
use App\Models\ManagedEnvironment;
use App\Models\User;
use App\Services\OperationRunService;
use App\Support\OperationRunOutcome;
use App\Support\OperationRunStatus;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Throwable;

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

    public ?OperationRun $operationRun = null;

    public function __construct(
        public int $tenantId,
        public int $userId,
        /** @var array<int, int|string> */
        public array $restoreRunIds,
        ?OperationRun $operationRun = null,
    ) {
        $this->operationRun = $operationRun;
    }

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

    public function handle(OperationRunService $operationRunService): void
    {
        $tenant = ManagedEnvironment::query()->find($this->tenantId);
        if (! $tenant instanceof ManagedEnvironment) {
            throw new \RuntimeException('ManagedEnvironment not found.');
        }

        $user = User::query()->find($this->userId);
        if (! $user instanceof User) {
            throw new \RuntimeException('User not found.');
        }

        $ids = collect($this->restoreRunIds)
            ->map(static fn ($id): int => (int) $id)
            ->unique()
            ->sort()
            ->values()
            ->all();

        $itemCount = 0;
        $succeeded = 0;
        $failed = 0;
        $skipped = 0;
        $skipReasons = [];

        $failures = [];

        $totalItems = count($ids);
        $failureThreshold = (int) floor($totalItems / 2);

        foreach ($ids as $restoreRunId) {
            $itemCount++;

            try {
                /** @var RestoreRun|null $restoreRun */
                $restoreRun = RestoreRun::withTrashed()
                    ->where('managed_environment_id', $tenant->getKey())
                    ->whereKey($restoreRunId)
                    ->first();

                if (! $restoreRun) {
                    $failed++;
                    $failures[] = ['code' => 'restore_run.not_found', 'message' => "Restore run {$restoreRunId} not found."];

                    if ($failed > $failureThreshold) {
                        if ($this->operationRun) {
                            $operationRunService->updateRun(
                                $this->operationRun,
                                status: OperationRunStatus::Completed->value,
                                outcome: OperationRunOutcome::Failed->value,
                                summaryCounts: [
                                    'total' => $totalItems,
                                    'processed' => $itemCount,
                                    'succeeded' => $succeeded,
                                    'failed' => $failed,
                                    'skipped' => $skipped,
                                ],
                                failures: array_merge($failures, [
                                    ['code' => 'restore_run.circuit_breaker', 'message' => 'Circuit breaker: more than 50% of items failed.'],
                                ]),
                            );
                        }

                        return;
                    }

                    continue;
                }

                if (! $restoreRun->trashed()) {
                    $skipped++;
                    $skipReasons['Not archived'] = ($skipReasons['Not archived'] ?? 0) + 1;

                    continue;
                }

                $restoreRun->restore();
                $succeeded++;
            } catch (Throwable $e) {
                $failed++;
                $failures[] = ['code' => 'restore_run.restore.failed', 'message' => $e->getMessage()];

                if ($failed > $failureThreshold) {
                    if ($this->operationRun) {
                        $operationRunService->updateRun(
                            $this->operationRun,
                            status: OperationRunStatus::Completed->value,
                            outcome: OperationRunOutcome::Failed->value,
                            summaryCounts: [
                                'total' => $totalItems,
                                'processed' => $itemCount,
                                'succeeded' => $succeeded,
                                'failed' => $failed,
                                'skipped' => $skipped,
                            ],
                            failures: array_merge($failures, [
                                ['code' => 'restore_run.circuit_breaker', 'message' => 'Circuit breaker: more than 50% of items failed.'],
                            ]),
                        );
                    }

                    return;
                }
            }
        }

        $outcome = OperationRunOutcome::Succeeded->value;

        if ($failed > 0 && $failed < $totalItems) {
            $outcome = OperationRunOutcome::PartiallySucceeded->value;
        }

        if ($failed >= $totalItems && $totalItems > 0) {
            $outcome = OperationRunOutcome::Failed->value;
        }

        if ($this->operationRun) {
            $operationRunService->updateRun(
                $this->operationRun,
                status: OperationRunStatus::Completed->value,
                outcome: $outcome,
                summaryCounts: [
                    'total' => $totalItems,
                    'processed' => $totalItems,
                    'succeeded' => $succeeded,
                    'failed' => $failed,
                    'skipped' => $skipped,
                ],
                failures: $failures,
            );
        }

    }
}
