<?php

namespace App\Services\GesconImport\Modules;

use App\Services\GesconImport\ImportProgressLogger;
use App\Services\GesconImport\Modules\Contracts\ImportModule;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Str;
use Throwable;

class AnagraficheImportModule extends BaseImportModule implements ImportModule
{
    private const VALID_STEPS = ['soggetti', 'diritti'];

    public function handle(array $payload, ImportContext $context): array
    {
        $legacy = (string) ($payload['legacy_code'] ?? '');
        if ($legacy === '') {
            throw new \InvalidArgumentException('legacy_code è obbligatorio.');
        }

        $steps = $this->normalizeSteps((array) ($payload['steps'] ?? ['soggetti', 'diritti']));
        if (empty($steps)) {
            $steps = ['soggetti', 'diritti'];
        }

        // Garanzia ruoli: se importiamo soggetti ma non diritti, aggiungi diritti automaticamente
        if (in_array('soggetti', $steps, true) && !in_array('diritti', $steps, true)) {
            $steps[] = 'diritti';
        }

        $anno = isset($payload['anno']) ? (int) $payload['anno'] : null;
        $mdbCondomin = (string) ($payload['mdb_condomin_path'] ?? '');
        $dry = (bool) ($payload['dry_run'] ?? true);
        $limit = isset($payload['limit']) ? (int) $payload['limit'] : null;
        $scala = isset($payload['scala']) ? (string) $payload['scala'] : null;
        $pianoMin = Arr::get($payload, 'piano_min');
        $pianoMax = Arr::get($payload, 'piano_max');
        $onlyPert = isset($payload['only_pertinenze']) ? (string) $payload['only_pertinenze'] : null;
        $splitMode = $payload['split_mode'] ?? null;
        $targetStabileId = array_key_exists('target_stabile_id', $payload) ? (int) $payload['target_stabile_id'] : null;
        $targetStabileCode = array_key_exists('target_stabile_code', $payload)
            ? trim((string) $payload['target_stabile_code'])
            : null;
        $targetStabileCode = $targetStabileCode === '' ? null : $targetStabileCode;
        $targetAdminIdOverride = isset($payload['target_admin_id']) ? (int) $payload['target_admin_id'] : null;

        if (!$mdbCondomin) {
            $mdbCondomin = $this->resolveMdbPath($legacy, $anno);
        }

        [$targetStabileId, $targetStabileCode, $splitMode, $targetAdminId] = $this->hydrateMappingPreferences(
            $context,
            $legacy,
            $targetStabileId,
            $targetStabileCode,
            $splitMode,
            'anagrafiche_last_filters'
        );

        if ($targetAdminIdOverride && $this->canTargetAdmin($context, $targetAdminIdOverride)) {
            $targetAdminId = $targetAdminIdOverride;
        }

        $logger = new ImportProgressLogger();
        $logger->begin('import-anagrafiche', [
            'legacy_code' => $legacy,
            'anno' => $anno,
            'steps' => $steps,
            'dry' => $dry,
        ]);

        $results = [];
        foreach ($steps as $step) {
            try {
                Artisan::call('gescon:import-full', $this->buildArtisanParams([
                    '--solo' => $step,
                    '--stabile' => $legacy,
                    '--mdb-condomin' => $mdbCondomin,
                    '--anno' => $anno,
                    '--dry-run' => $dry,
                    '--limit' => $limit,
                    '--scala' => $scala,
                    '--piano-min' => $pianoMin !== null ? (string) $pianoMin : null,
                    '--piano-max' => $pianoMax !== null ? (string) $pianoMax : null,
                    '--only-pertinenze' => $onlyPert,
                    '--split-mode' => $splitMode,
                    '--target-stabile-id' => $targetStabileId,
                    '--target-stabile-code' => $targetStabileCode,
                    '--amministratore-id' => $targetAdminId,
                ]));

                $output = (string) Artisan::output();
                $logger->checkpoint('step.done', ['step' => $step]);
                $logger->stdout("\n===== STEP {$step} =====\n" . $output . "\n");
                $results[] = ['step' => $step, 'ok' => true, 'output' => $output];
            } catch (Throwable $e) {
                $logger->error('step.error', ['step' => $step, 'error' => $e->getMessage()]);
                $results[] = ['step' => $step, 'ok' => false, 'error' => $e->getMessage()];
            }
        }

        $logger->finish(['results' => array_map(fn ($r) => ['step' => $r['step'], 'ok' => $r['ok']], $results)]);
        $this->persistMappingMeta(
            $context,
            $legacy,
            $targetStabileId,
            $targetStabileCode,
            $targetAdminId,
            [
                'anno' => $anno,
                'scala' => $scala,
                'piano_min' => $pianoMin,
                'piano_max' => $pianoMax,
                'only_pertinenze' => $onlyPert,
                'split_mode' => $splitMode,
                'dry' => $dry,
                'limit' => $limit,
                'steps' => $steps,
            ],
            'anagrafiche_last_filters'
        );

        return [
            'ok' => !collect($results)->contains(fn ($r) => $r['ok'] === false),
            'legacy_code' => $legacy,
            'anno' => $anno,
            'mdb_condomin_path' => $mdbCondomin,
            'dry_run' => $dry,
            'split_mode' => $splitMode,
            'target_stabile_id' => $targetStabileId,
            'target_stabile_code' => $targetStabileCode,
            'target_admin_id' => $targetAdminId,
            'steps' => $steps,
            'results' => $results,
        ];
    }

    private function normalizeSteps(array $steps): array
    {
        return collect($steps)
            ->map(fn ($step) => Str::lower(trim((string) $step)))
            ->filter(fn ($step) => in_array($step, self::VALID_STEPS, true))
            ->unique()
            ->values()
            ->all();
    }
}