<?php

declare(strict_types=1);

namespace App\Console\Commands;

use App\Jobs\BackfillFindingLifecycleJob;
use App\Models\Tenant;
use App\Services\OperationRunService;
use Illuminate\Console\Command;

class TenantpilotBackfillFindingLifecycle extends Command
{
    protected $signature = 'tenantpilot:findings:backfill-lifecycle
        {--tenant=* : Limit to tenant_id/external_id}';

    protected $description = 'Queue tenant-scoped findings lifecycle backfill jobs idempotently.';

    public function handle(OperationRunService $operationRuns): int
    {
        $tenantIdentifiers = array_values(array_filter((array) $this->option('tenant')));

        if ($tenantIdentifiers === []) {
            $this->error('Provide one or more tenants via --tenant={id|external_id}.');

            return self::FAILURE;
        }

        $tenants = $this->resolveTenants($tenantIdentifiers);

        if ($tenants->isEmpty()) {
            $this->info('No tenants matched the provided identifiers.');

            return self::SUCCESS;
        }

        $queued = 0;
        $skipped = 0;

        foreach ($tenants as $tenant) {
            if (! $tenant instanceof Tenant) {
                continue;
            }

            $run = $operationRuns->ensureRunWithIdentity(
                tenant: $tenant,
                type: 'findings.lifecycle.backfill',
                identityInputs: [
                    'tenant_id' => (int) $tenant->getKey(),
                    'trigger' => 'backfill',
                ],
                context: [
                    'workspace_id' => (int) $tenant->workspace_id,
                    'source' => 'tenantpilot:findings:backfill-lifecycle',
                ],
                initiator: null,
            );

            if (! $run->wasRecentlyCreated) {
                $skipped++;

                continue;
            }

            $operationRuns->dispatchOrFail($run, function () use ($tenant): void {
                BackfillFindingLifecycleJob::dispatch(
                    tenantId: (int) $tenant->getKey(),
                    workspaceId: (int) $tenant->workspace_id,
                    initiatorUserId: null,
                );
            });

            $queued++;
        }

        $this->info(sprintf(
            'Queued %d backfill run(s), skipped %d duplicate run(s).',
            $queued,
            $skipped,
        ));

        return self::SUCCESS;
    }

    /**
     * @param  array<int, string>  $tenantIdentifiers
     * @return \Illuminate\Support\Collection<int, Tenant>
     */
    private function resolveTenants(array $tenantIdentifiers)
    {
        $tenantIds = [];

        foreach ($tenantIdentifiers as $identifier) {
            $tenant = Tenant::query()
                ->forTenant($identifier)
                ->first();

            if ($tenant instanceof Tenant) {
                $tenantIds[] = (int) $tenant->getKey();
            }
        }

        $tenantIds = array_values(array_unique($tenantIds));

        if ($tenantIds === []) {
            return collect();
        }

        return Tenant::query()
            ->whereIn('id', $tenantIds)
            ->orderBy('id')
            ->get();
    }
}