<?php

namespace App\Jobs;

use App\Jobs\Concerns\BridgesFailedOperationRun;
use App\Jobs\Operations\BackupSetRestoreWorkerJob;
use App\Models\OperationRun;
use App\Services\OperationRunService;
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 BulkBackupSetRestoreJob implements ShouldQueue
{
    use BridgesFailedOperationRun;
    use Dispatchable;
    use InteractsWithQueue;
    use Queueable;
    use SerializesModels;

    public int $timeout = 300;

    public bool $failOnTimeout = true;

    public int $bulkRunId = 0;

    public ?OperationRun $operationRun = null;

    /**
     * @param  array<int, mixed>  $backupSetIds
     * @param  array<string, mixed>  $context
     */
    public function __construct(
        public int $tenantId,
        public int $userId,
        public array $backupSetIds,
        ?OperationRun $operationRun = null,
        public array $context = [],
    ) {
        $this->operationRun = $operationRun;
        $this->bulkRunId = $operationRun?->getKey() ? (int) $operationRun->getKey() : 0;
    }

    public function handle(OperationRunService $runs): void
    {
        $this->operationRun = $this->resolveOperationRun();

        $this->operationRun->refresh();

        if ($this->operationRun->status === 'completed') {
            return;
        }

        $runs->updateRun($this->operationRun, 'running');

        $ids = $this->normalizeIds($this->backupSetIds);
        $existingCounts = is_array($this->operationRun->summary_counts ?? null)
            ? $this->operationRun->summary_counts
            : [];

        $this->operationRun = $runs->updateRun(
            $this->operationRun,
            status: 'running',
            summaryCounts: [
                'total' => max((int) ($existingCounts['total'] ?? 0), count($ids)),
                'processed' => (int) ($existingCounts['processed'] ?? 0),
                'succeeded' => (int) ($existingCounts['succeeded'] ?? 0),
                'failed' => (int) ($existingCounts['failed'] ?? 0),
                'skipped' => (int) ($existingCounts['skipped'] ?? 0),
            ],
        );

        $chunkSize = (int) config('tenantpilot.bulk_operations.chunk_size', 10);
        $chunkSize = max(1, $chunkSize);

        foreach (array_chunk($ids, $chunkSize) as $chunk) {
            foreach ($chunk as $backupSetId) {
                dispatch(new BackupSetRestoreWorkerJob(
                    tenantId: $this->tenantId,
                    userId: $this->userId,
                    backupSetId: $backupSetId,
                    operationRun: $this->operationRun,
                    context: $this->context,
                ));
            }
        }
    }

    private function resolveOperationRun(): OperationRun
    {
        if ($this->operationRun instanceof OperationRun) {
            return $this->operationRun;
        }

        if ($this->bulkRunId > 0) {
            $run = OperationRun::query()->find($this->bulkRunId);

            if ($run instanceof OperationRun) {
                return $run;
            }
        }

        throw new RuntimeException('OperationRun is required for BulkBackupSetRestoreJob.');
    }

    /**
     * @param  array<int, mixed>  $ids
     * @return array<int, int>
     */
    private function normalizeIds(array $ids): array
    {
        $normalized = [];

        foreach ($ids as $id) {
            if (is_int($id)) {
                $normalized[] = $id;

                continue;
            }

            if (is_numeric($id)) {
                $normalized[] = (int) $id;
            }
        }

        $normalized = array_values(array_unique($normalized));
        sort($normalized);

        return $normalized;
    }
}
