<?php
namespace App\Support;

use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;

class GestioneVisibility
{
    public static function policyForStabile(int $stabileId, ?int $fallbackYear = null): array
    {
        $fallback = $fallbackYear !== null && $fallbackYear >= 2000 && $fallbackYear <= 2100
            ? $fallbackYear
            : null;

        if ($stabileId <= 0 || ! Schema::hasTable('gestioni_contabili')) {
            return self::fallbackPolicy($fallback);
        }

        $rows = DB::table('gestioni_contabili')
            ->where('stabile_id', $stabileId)
            ->whereNotNull('anno_gestione')
            ->orderByDesc('anno_gestione')
            ->get(['anno_gestione', 'stato', 'gestione_attiva']);

        if ($rows->isEmpty()) {
            return self::fallbackPolicy($fallback);
        }

        $years = [];
        foreach ($rows as $row) {
            $year = is_numeric($row->anno_gestione ?? null) ? (int) $row->anno_gestione : null;
            if (! $year) {
                continue;
            }

            $years[$year] ??= [
                'year'   => $year,
                'closed' => true,
                'active' => false,
            ];

            $isClosed               = self::isClosedState($row->stato ?? null);
            $years[$year]['closed'] = $years[$year]['closed'] && $isClosed;
            $years[$year]['active'] = $years[$year]['active'] || (bool) ($row->gestione_attiva ?? false);
        }

        if ($years === []) {
            return self::fallbackPolicy($fallback);
        }

        krsort($years);

        $countableYears = [];
        $closedYears    = [];
        foreach ($years as $year => $meta) {
            if (($meta['closed'] ?? false) === true && ($meta['active'] ?? false) === false) {
                $closedYears[] = (int) $year;
                continue;
            }

            $countableYears[] = (int) $year;
        }

        $visibleYears = $countableYears;
        if ($closedYears !== []) {
            $visibleYears[] = (int) $closedYears[0];
        }

        if ($visibleYears === [] && $fallback !== null) {
            $visibleYears[] = $fallback;
        }

        if ($countableYears === [] && $fallback !== null && ! in_array($fallback, $closedYears, true)) {
            $countableYears[] = $fallback;
            if (! in_array($fallback, $visibleYears, true)) {
                $visibleYears[] = $fallback;
            }
        }

        $visibleYears = array_values(array_unique(array_map('intval', $visibleYears)));
        rsort($visibleYears);

        $countableYears = array_values(array_unique(array_map('intval', $countableYears)));
        rsort($countableYears);

        $closedVisibleYears = array_values(array_filter($visibleYears, static fn(int $year): bool => in_array($year, $closedYears, true)));
        $hiddenYears        = array_values(array_filter(array_map('intval', array_keys($years)), static fn(int $year): bool => ! in_array($year, $visibleYears, true)));

        return [
            'visible_years'        => $visibleYears,
            'countable_years'      => $countableYears,
            'closed_visible_years' => $closedVisibleYears,
            'hidden_years'         => $hiddenYears,
        ];
    }

    public static function matchesYear(?int $year, array $years): bool
    {
        if ($years === []) {
            return true;
        }

        return $year !== null && in_array($year, $years, true);
    }

    public static function normalizeCalendarYear(mixed $value): ?int
    {
        if (! is_numeric($value)) {
            return null;
        }

        $year = (int) $value;

        return $year >= 2000 && $year <= 2100 ? $year : null;
    }

    private static function fallbackPolicy(?int $fallbackYear): array
    {
        $visible = $fallbackYear !== null ? [$fallbackYear] : [];

        return [
            'visible_years'        => $visible,
            'countable_years'      => $visible,
            'closed_visible_years' => [],
            'hidden_years'         => [],
        ];
    }

    private static function isClosedState(mixed $state): bool
    {
        $normalized = strtolower(trim((string) $state));

        return in_array($normalized, ['chiusa', 'chiuso', 'consolidata', 'consolidato'], true);
    }
}