<?php

namespace App\Services\AtencaoBasica\RelatorioInconsistencia;

use App\Enums\AtencaoBasica\Parametrizacao\Permissao;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissao;
use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Rules\AtencaoBasica\Exportacao\CnesIsValid;
use App\Rules\AtencaoBasica\Exportacao\IbgeIsValid;
use App\Rules\AtencaoBasica\Exportacao\OcupacaoIsAllowed;
use App\Rules\Cns;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class RelatorioInconsistenciaService extends Service
{
    private const ACTIVITY_TABLES = [
        ['atencao_basica_avaliacao', 'data'],
        ['atencao_basica_cadastro_domiciliar', 'data_usuario_responsavel'],
        ['atencao_basica_cadastro_individual', 'data_usuario_responsavel'],
        ['atencao_basica_ficha_complementar', 'data_atendimento'],
        ['atencao_basica_consumo_alimentar', 'data_atendimento'],
        ['atencao_basica_procedimento', 'data_usuario_responsavel'],
        ['atencao_basica_visita_domiciliar', 'data_usuario_responsavel'],
        ['atencao_basica_atendimento_domiciliar', 'data'],
        ['atencao_basica_atendimento_individual', 'data_usuario_responsavel'],
        ['atencao_basica_atendimento_odontologico', 'data_atendimento'],
        ['atencao_basica_atividade_coletiva', 'data_usuario_responsavel'],
    ];

    public static function index()
    {
        return [
            'form' => self::getFormData(),
            'model' => self::getModelData(),
        ];
    }

    private static function getFormData()
    {
        return [
            'fichas' => self::getFichas(),
            'data_atual' => Carbon::now()->format('Y-m-d'),
            'mesesAno' => self::getPeriodo(),
        ];
    }

    public static function getFichas()
    {
        return DB::table('atencao_basica_parametrizacao_outros_permissao')
            ->select([
                'id',
                'descricao'
            ])
            ->orderBy('atencao_basica_parametrizacao_outros_permissao.descricao')
            ->get();
    }

    private static function getDateRange(string $mes_ano): array
    {
        $date = Carbon::createFromFormat('mY', $mes_ano);

        return [
            $date->copy()->startOfMonth()->toDateString(),
            $date->copy()->endOfMonth()->toDateString(),
        ];
    }

    private static function getActiveEquipeIds(string $start, string $end): array
    {
        $equipeIds = [];

        foreach (self::ACTIVITY_TABLES as [$table, $dateCol]) {

            $ids = DB::table($table)
                ->whereBetween($dateCol, [$start, $end])
                ->distinct()
                ->pluck('equipe_id')
                ->all();

            foreach ($ids as $id) {

                if ($id !== null) {
                    $equipeIds[$id] = true;
                }
            }
        }

        return array_keys($equipeIds);
    }

    public static function getUnidades()
    {
        [$start, $end] = self::getDateRange(request()->mes_ano);

        $equipeIds = self::getActiveEquipeIds($start, $end);

        if (empty($equipeIds)) {
            return collect();
        }

        return DB::table('cadastro_unidade')
            ->select(['id', 'nome_fantasia'])
            ->whereIn('id', function ($q) use ($equipeIds) {
                $q->select('unidade_id')
                    ->from('atencao_basica_parametrizacao_equipe')
                    ->whereIn('id', $equipeIds)
                    ->whereNotNull('unidade_id');
            })
            ->orderBy('nome_fantasia')
            ->get();
    }

    public static function getInfraestruturas()
    {
        [$start, $end] = self::getDateRange(request()->mes_ano);

        $equipeIds = self::getActiveEquipeIds($start, $end);

        if (empty($equipeIds)) {

            return [
                'infraestruturas' => collect(),
                'usuarios' => self::getUsuarios(),
            ];
        }

        $infraestruturaIds = DB::table('atencao_basica_parametrizacao_equipe')
            ->whereIn('id', $equipeIds)
            ->whereNotNull('infraestrutura_id')
            ->when(request()->unidade_id, fn ($q) => $q->where('unidade_id', request()->unidade_id))
            ->distinct()
            ->pluck('infraestrutura_id')
            ->all();

        $infraestruturas = DB::table('cadastro_infraestrutura')
            ->select([
                'cadastro_infraestrutura.id',
                DB::raw('COALESCE(cadastro_infraestrutura.nome, cadastro_unidade.nome_fantasia) AS nome'),
            ])
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'cadastro_infraestrutura.unidade_id')
            ->whereIn('cadastro_infraestrutura.id', $infraestruturaIds)
            ->when(request()->unidade_id, fn ($q) => $q->where('cadastro_infraestrutura.unidade_id', request()->unidade_id))
            ->orderBy('nome')
            ->get();

        return [
            'infraestruturas' => $infraestruturas,
            'usuarios' => self::getUsuarios(),
        ];
    }

    public static function getUsuarios()
    {
        [$start, $end] = self::getDateRange(request()->mes_ano);

        $equipeIds = null;

        if (request()->unidade_id || request()->infraestrutura_id) {

            $equipeIds = DB::table('atencao_basica_parametrizacao_equipe')
                ->when(request()->unidade_id, fn ($q) => $q->where('unidade_id', request()->unidade_id))
                ->when(request()->infraestrutura_id, fn ($q) => $q->where('infraestrutura_id', request()->infraestrutura_id))
                ->pluck('id')
                ->all();

            if (empty($equipeIds)) {
                return collect();
            }
        }

        $usuarioIds = [];

        foreach (self::ACTIVITY_TABLES as [$table, $dateCol]) {

            $ids = DB::table($table)
                ->whereBetween($dateCol, [$start, $end])
                ->when($equipeIds, fn ($q) => $q->whereIn('equipe_id', $equipeIds))
                ->distinct()
                ->pluck('usuario_id')
                ->all();

            foreach ($ids as $id) {

                if ($id !== null) {
                    $usuarioIds[$id] = true;
                }
            }
        }

        if (empty($usuarioIds)) {
            return collect();
        }

        return DB::table('cadastro_usuario')
            ->select('cadastro_usuario.id', 'cadastro_cidadao.nome')
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->whereIn('cadastro_usuario.id', array_keys($usuarioIds))
            ->orderBy('cadastro_cidadao.nome')
            ->get();
    }

    public static function getPeriodo()
    {
        $dataAtual = Carbon::now();
        $dataInicial = $dataAtual->copy()->subYear();
        $mesesAnos = [];

        while ($dataAtual >= $dataInicial) {

            $mesesAnos[] = [
                'value' => $dataAtual->format('mY'),
                'text' => ucfirst($dataAtual->translatedFormat('F/Y')),
            ];

            $dataAtual->subMonth();
        }

        return $mesesAnos;
    }

    private static function getModelData()
    {
        return [
            'periodo' => [
                'start' => null,
                'end' => null,
            ],
            'unidade_id' => null,
            'infraestrutura_id' => null,
            'usuario_id' => null,
            'ficha_id' => null,
            'mesAno' => null,
        ];
    }

    public static function list()
    {
        $errors = collect();

        if (!request()->ficha_id || request()->ficha_id == Permissao::MARCADORES_DE_CONSUMO_ALIMENTAR) {

            $errors = $errors->merge(FichaConsumoAlimentarService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::PROCEDIMENTOS) {

            $errors = $errors->merge(FichaProcedimentoService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::ATENDIMENTO_INDIVIDUAL) {

            $errors = $errors->merge(FichaAtendimentoIndividualService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::ATENDIMENTO_ODONTOLOGICO) {

            $errors = $errors->merge(FichaAtendimentoOdontologicoService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::ATENDIMENTO_DOMICILIAR) {

            $errors = $errors->merge(FichaAtendimentoDomiciliarService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::FICHA_COMPLEMENTAR) {

            $errors = $errors->merge(FichaComplementarService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::VISITA_DOMICILIAR) {

            $errors = $errors->merge(FichaVisitaDomiciliarService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::AVALIACAO_ELEGIBILIDADE_ADMISSAO) {

            $errors = $errors->merge(FichaAvaliacaoElegibilidadeService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::CADASTRO_INDIVIDUAL) {

            $errors = $errors->merge(FichaCadastroIndividualService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::CADASTRO_DOMICILIAR) {

            $errors = $errors->merge(FichaCadastroDomiciliarService::index());
        }

        if (!request()->ficha_id || request()->ficha_id == Permissao::ATIVIDADE_COLETIVA) {

            $errors = $errors->merge(FichaAtividadeColetivaService::index());
        }

        return $errors;
    }


    public static function getEquipes()
    {
        return DB::table('atencao_basica_atendimento_odontologico as atendimento')
            ->select('equipe.id')
            ->join('atencao_basica_parametrizacao_equipe as equipe', 'equipe.id', 'atendimento.equipe_id')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'equipe.unidade_id')
            ->where('atendimento.data_atendimento', '>=', request()->data_inicial)
            ->where('atendimento.data_atendimento', '<=', request()->data_final)
            ->when(request()->unidade_id, function($query) {
                $query->where('atendimento.unidade_id', request()->unidade_id);
            })
            ->orderBy('equipe.id')
            ->groupBy('equipe.id')
            ->get();
    }

    public static function getPrintExportData()
    {
        $items = self::list();

        return [
            'items' => $items,
            'competencia' => self::getCompetencia(request()->mes_ano),
            'unidade' => request()->unidade_id ? Unidade::find(request()->unidade_id)->nome_fantasia : 'Todas',
            'infraestrutura' => request()->infraestrutura_id ? Infraestrutura::find(request()->infraestrutura_id)->nome : 'Todos',
            'usuario' => request()->usuario_id ? Usuario::find(request()->usuario_id)->nome : 'Todos',
            'ficha' => request()->ficha_id ? OutrosPermissao::find(request()->ficha_id)->descricao : 'Todas',
            'colunas' => collect(request()->selectedCols),
        ];
    }

    private static function getCompetencia($date_str)
    {

        $month_names = [
            "Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho",
            "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"
        ];

        $month_index = intval(substr($date_str, 0, 2)) - 1;
        $year_str = substr($date_str, 2);

        $month_name = $month_names[$month_index];

        $formatted_date = "{$month_name}/{$year_str}";

        return $formatted_date;
    }

    public static function validHeader($ficha, $funcionalidade)
    {
        $errors = collect();

        if (!CnesIsValid::isValid($ficha->unidade_cnes)) {
            $errors->push(CnesIsValid::class);
        }

        if (!IbgeIsValid::isValid($ficha->municipio_ibge)) {
            $errors->push(IbgeIsValid::class);
        }

        if (!Cns::isValid($ficha->usuario_cns)) {
            $errors->push(Cns::class);
        }

        if (!OcupacaoIsAllowed::isValid(['permissao_id' => $funcionalidade, 'ocupacao' => $ficha->ocupacao_codigo])) {
            $errors->push(OcupacaoIsAllowed::class);
        }

        return $errors;
    }
}