<?php

namespace App\Services\AtencaoBasica;

use App\Enums\AtencaoBasica\AtendimentoDomiciliar\CondicaoAvaliada;
use App\Enums\AtencaoBasica\AtendimentoDomiciliar\CondutaDesfecho;
use App\Enums\AtencaoBasica\AtendimentoDomiciliar\Modalidade;
use App\Enums\AtencaoBasica\AtendimentoDomiciliar\PerfilEpidemiologico;
use App\Enums\AtencaoBasica\AtendimentoIndividual\LocalAtendimento;
use App\Enums\AtencaoBasica\Avaliacao\Conclusao;
use App\Enums\AtencaoBasica\Avaliacao\JustificativaConclusao;
use App\Enums\AtencaoBasica\Avaliacao\Procedencia;
use App\Enums\Sigtap\Ocupacao;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;

class RelatorioIndicadorSadService extends Service
{
    public static function index()
    {
        $params = self::getParams();

        return [
            'levantamento_quantitativo' => self::getLevantamentoQuantitativoData($params),
            'admissao' => self::getAdmissaoData($params),
            'pacientes_em_atendimento' => self::getPacientesEmAtendimentoData($params),
            'servicoes_origem' => self::getServicoesOrigemData($params),
            'media_permanencia' => self::getMediaPermanenciaData($params),
            'alta' => self::getAltaData($params),
            'visitas' => self::getVisitasData($params),
            'perfil_epidemiologico' => self::getPerfilEpidemiologicoData($params),
            'atendimentos_por_categoria' => self::getAtendimentosPorCategoriaData($params),
            'dados_epidemiologicos_gerais' => self::getDadosEpidemiologicosGeraisData($params),
        ];
    }

    private static function getLevantamentoQuantitativoData($params)
    {
        $get = function ($ano, $mes) use ($params) {

            return DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
                ->join(
                    'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                    'atendimento_domiciliar.id',
                    'atendimento.atendimento_domiciliar_id'
                )
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->whereYear('atendimento_domiciliar.data', $ano)
                ->whereMonth('atendimento_domiciliar.data', $mes)
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
                ->selectRaw('COUNT(DISTINCT atendimento.paciente_id) AS quantidade')
                ->first()->quantidade ?? 0;
        };

        $periodoAnterior = Carbon::create($params->ano, $params->mes)->subMonth();

        return [
            'titulo' => 'Levantamento quantitativo',
            'itens' => [
                [
                    'descricao' => 'Nº de pacientes total em atendimento no período anterior',
                    'quantidade' => $get($periodoAnterior->format('Y'), $periodoAnterior->format('m'))
                ],
                [
                    'descricao' => 'Nº de pacientes total em atendimento no período vigente',
                    'quantidade' => $get($params->ano, $params->mes)
                ],
            ],
            'rodape' => 'Obs.: Quantidade = contagem de pacientes em atendimento no período anterior e contagem de pacientes '
                . 'em atendimento no período vigente',
        ];
    }

    private static function getAdmissaoData($params)
    {
        $get = function ($conclusaoId) use ($params) {

            return DB::table('atencao_basica_avaliacao AS avaliacao')
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'avaliacao.equipe_id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->whereYear('avaliacao.data', $params->ano)
                ->whereMonth('avaliacao.data', $params->mes)
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                ->when($params->equipe_id, fn ($q, $id) => $q->where('avaliacao.equipe_id', $id))
                ->where('avaliacao.conclusao_id', $conclusaoId)
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('atencao_basica_avaliacao_justificativa AS justificativa')
                    ->whereColumn('justificativa.avaliacao_id', 'avaliacao.id')
                    ->where('justificativa.justificativa_id', JustificativaConclusao::ADMISSAO_NA_PROPRIA_EMAD)
                )
                ->selectRaw('COUNT(DISTINCT avaliacao.paciente_id) AS quantidade')
                ->first()->quantidade ?? 0;
        };

        $quantidadeAd1 = $get(Conclusao::ELEGIVEL_AD1);
        $quantidadeAd2 = $get(Conclusao::ELEGIVEL_AD2);
        $quantidadeAd3 = $get(Conclusao::ELEGIVEL_AD3);
        $quantidadeGeral = $quantidadeAd1 + $quantidadeAd2 + $quantidadeAd3;

        return [
            'titulo' => 'Admissão',
            'itens' => [
                [
                    'descricao' => 'Total de pacientes admitidos no período',
                    'quantidade' => $quantidadeGeral,
                    'percentual' => self::getPercentual($quantidadeGeral, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes classificados em AD1 admitidos no período',
                    'quantidade' => $quantidadeAd1,
                    'percentual' => self::getPercentual($quantidadeAd1, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes classificados em AD2 admitidos no período',
                    'quantidade' => $quantidadeAd2,
                    'percentual' => self::getPercentual($quantidadeAd2, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes classificados em AD3 admitidos no período',
                    'quantidade' => $quantidadeAd3,
                    'percentual' => self::getPercentual($quantidadeAd3, $quantidadeGeral),
                ],
            ],
            'rodape' => 'Obs.: % por modalidade = (Nº de pacientes classificados na modalidade AD1 ou AD2 ou AD3 x 100) ÷ '
                . '(Total de pacientes admitidos no período)'
        ];
    }

    private static function getPacientesEmAtendimentoData($params)
    {
        $get = function ($modalidadeId) use ($params) {

            return DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
                ->join(
                    'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                    'atendimento_domiciliar.id',
                    'atendimento.atendimento_domiciliar_id'
                )
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->whereYear('atendimento_domiciliar.data', $params->ano)
                ->whereMonth('atendimento_domiciliar.data', $params->mes)
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
                ->where('atendimento.modalidade_id', $modalidadeId)
                ->selectRaw('COUNT(DISTINCT atendimento.paciente_id) AS quantidade')
                ->first()->quantidade ?? 0;
        };

        $quantidadeAd1 = $get(Modalidade::AD_1);
        $quantidadeAd2 = $get(Modalidade::AD_2);
        $quantidadeAd3 = $get(Modalidade::AD_3);
        $quantidadeGeral = $quantidadeAd1 + $quantidadeAd2 + $quantidadeAd3;

        return [
            'titulo' => 'Pacientes em atendimento',
            'itens' => [
                [
                    'descricao' => 'Total de pacientes AD1',
                    'quantidade' => $quantidadeAd1,
                    'percentual' => self::getPercentual($quantidadeAd1, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes AD2',
                    'quantidade' => $quantidadeAd2,
                    'percentual' => self::getPercentual($quantidadeAd2, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes AD3',
                    'quantidade' => $quantidadeAd3,
                    'percentual' => self::getPercentual($quantidadeAd3, $quantidadeGeral),
                ],
            ],
            'rodape' => 'Obs.: % por modalidade = (Nº de pacientes na modalidade AD1 ou AD2 ou AD3 x 100) ÷ '
                . '(Total de pacientes em atendimento no período)'
        ];
    }

    private static function getServicoesOrigemData($params)
    {
        $get = function ($procedenciaId = null, $outrasProcedencias = false) use ($params) {

            return DB::table('atencao_basica_avaliacao AS avaliacao')
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'avaliacao.equipe_id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->whereYear('avaliacao.data', $params->ano)
                ->whereMonth('avaliacao.data', $params->mes)
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                ->when($params->equipe_id, fn ($q, $id) => $q->where('avaliacao.equipe_id', $id))
                ->when($outrasProcedencias,
                    fn ($q) => $q->whereNotIn('avaliacao.procedencia_id', [
                        Procedencia::ATENCAO_BASICA,
                        Procedencia::INTERNACAO_HOSPITALAR,
                        Procedencia::URGENCIA_E_EMERGENCIA,
                    ]),
                    fn ($q) => $q->where('avaliacao.procedencia_id', $procedenciaId)
                )
                ->selectRaw('COUNT(DISTINCT avaliacao.paciente_id) AS quantidade')
                ->first()->quantidade ?? 0;
        };

        $quantidadeAtencaoBasica = $get(Procedencia::ATENCAO_BASICA);
        $quantidadeHospitais = $get(Procedencia::INTERNACAO_HOSPITALAR);
        $quantidadeUrgenciaEmergencia = $get(Procedencia::URGENCIA_E_EMERGENCIA);
        $quantidadeOutras = $get(null, true);

        $quantidadeGeral = $quantidadeAtencaoBasica
            + $quantidadeHospitais
            + $quantidadeUrgenciaEmergencia
            + $quantidadeOutras;

        return [
            'titulo' => 'Serviços de origem',
            'itens' => [
                [
                    'descricao' => 'Total de pacientes admitidos no período na atenção básica',
                    'quantidade' => $quantidadeAtencaoBasica,
                    'percentual' => self::getPercentual($quantidadeAtencaoBasica, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes admitidos no período provenientes de hospitais',
                    'quantidade' => $quantidadeHospitais,
                    'percentual' => self::getPercentual($quantidadeHospitais, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes admitidos no período provenientes de urgência/emergência',
                    'quantidade' => $quantidadeUrgenciaEmergencia,
                    'percentual' => self::getPercentual($quantidadeUrgenciaEmergencia, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes admitidos no período de outras demandas',
                    'quantidade' => $quantidadeOutras,
                    'percentual' => self::getPercentual($quantidadeOutras, $quantidadeGeral),
                ],
            ],
            'rodape' => 'Obs.: % por origem = (Nº de pacientes admitidos por origem x 100) ÷ '
                . '(Total de pacientes admitidos no SAD no período)'
        ];
    }

    private static function getMediaPermanenciaData($params)
    {
        $datasPermanencia = [];
        $totalDiasPermanencia = 0;
        $pacientesComAlta = collect();

        DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
            ->join(
                'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                'atendimento_domiciliar.id',
                'atendimento.atendimento_domiciliar_id'
            )
            ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
            ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
            ->whereYear('atendimento_domiciliar.data', $params->ano)
            ->whereMonth('atendimento_domiciliar.data', $params->mes)
            ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
            ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
            ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
            ->whereIn('atendimento.conduta_desfecho_id', [
                CondutaDesfecho::PERMANENCIA,
                CondutaDesfecho::ALTA_ADMINISTRATIVA,
                CondutaDesfecho::ALTA_CLINICA,
                CondutaDesfecho::OBITO,
            ])
            ->select(
                'atendimento.paciente_id',
                'atendimento_domiciliar.data',
                'atendimento.conduta_desfecho_id',
            )
            ->orderBy('atendimento_domiciliar.data')
            ->get()
            ->each(function ($atendimento) use (&$datasPermanencia, &$totalDiasPermanencia, $pacientesComAlta) {

                if ($atendimento->conduta_desfecho_id === CondutaDesfecho::PERMANENCIA) {

                    if (!isset($datasPermanencia[$atendimento->paciente_id])) {

                        $datasPermanencia[$atendimento->paciente_id] = $atendimento->data;
                    }
                }
                else {

                    if (!$pacientesComAlta->contains($atendimento->paciente_id)) {

                        $pacientesComAlta->push($atendimento->paciente_id);
                    }

                    if (isset($datasPermanencia[$atendimento->paciente_id])) {

                        $totalDiasPermanencia += Carbon::create($datasPermanencia[$atendimento->paciente_id])
                            ->diff(Carbon::create($atendimento->data))
                            ->days;

                        unset($datasPermanencia[$atendimento->paciente_id]);
                    }
                }
            });

        return [
            'titulo' => 'Média de Permanência',
            'itens' => [
                [
                    'descricao' => 'Total de dias de permanência dos pacientes que tiveram alta do SAD no período',
                    'quantidade' => $totalDiasPermanencia,
                ],
                [
                    'descricao' => 'Total de pacientes que tiveram alta do SAD no período',
                    'quantidade' => $pacientesComAlta->count(),
                ],
            ],
            'rodape' => null
        ];
    }

    private static function getAltaData($params)
    {
        $get = function ($condutaDesfechoId) use ($params) {

            return DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
                ->join(
                    'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                    'atendimento_domiciliar.id',
                    'atendimento.atendimento_domiciliar_id'
                )
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->whereYear('atendimento_domiciliar.data', $params->ano)
                ->whereMonth('atendimento_domiciliar.data', $params->mes)
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
                ->where('atendimento.conduta_desfecho_id', $condutaDesfechoId)
                ->selectRaw('COUNT(DISTINCT atendimento.paciente_id) AS quantidade')
                ->first()->quantidade ?? 0;
        };

        $quantidadeAtencaoBasicaAd1 = $get(CondutaDesfecho::ATENCAO_BASICA_AD1);
        $quantidadeAltaClinica = $get(CondutaDesfecho::ALTA_CLINICA);
        $quantidadeAltaAdministrativa = $get(CondutaDesfecho::ALTA_ADMINISTRATIVA);
        $quantidadeServicoInternacaoHospitalar = $get(CondutaDesfecho::SERVICO_DE_INTERNACAO_HOSPITALAR);
        $quantidadeObito = $get(CondutaDesfecho::OBITO);

        $quantidadeGeral = $quantidadeAtencaoBasicaAd1
            + $quantidadeAltaClinica
            + $quantidadeAltaAdministrativa
            + $quantidadeServicoInternacaoHospitalar
            + $quantidadeObito;

        return [
            'titulo' => 'Alta',
            'itens' => [
                [
                    'descricao' => 'Total de pacientes que tiveram alta do SAD no período',
                    'quantidade' => $quantidadeGeral,
                    'percentual' => self::getPercentual($quantidadeGeral, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes com desfecho de encaminhamento para AD1',
                    'quantidade' => $quantidadeAtencaoBasicaAd1,
                    'percentual' => self::getPercentual($quantidadeAtencaoBasicaAd1, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes com desfecho de alta clínica',
                    'quantidade' => $quantidadeAltaClinica,
                    'percentual' => self::getPercentual($quantidadeAltaClinica, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes com desfecho de alta administrativa',
                    'quantidade' => $quantidadeAltaAdministrativa,
                    'percentual' => self::getPercentual($quantidadeAltaAdministrativa, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes com desfecho de alta por internação hospitalar',
                    'quantidade' => $quantidadeServicoInternacaoHospitalar,
                    'percentual' => self::getPercentual($quantidadeServicoInternacaoHospitalar, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Total de pacientes com desfecho de óbito',
                    'quantidade' => $quantidadeObito,
                    'percentual' => self::getPercentual($quantidadeObito, $quantidadeGeral),
                ],
            ],
            'rodape' => 'Obs.: % por desfecho = (Nº de pacientes com alta naquele desfecho x 100) ÷ '
                . '(Total de pacientes que tiveram alta no período)'
        ];
    }

    private static function getVisitasData($params)
    {
        $quantidadeVisitas = DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
            ->join(
                'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                'atendimento_domiciliar.id',
                'atendimento.atendimento_domiciliar_id'
            )
            ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
            ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
            ->whereYear('atendimento_domiciliar.data', $params->ano)
            ->whereMonth('atendimento_domiciliar.data', $params->mes)
            ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
            ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
            ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
            ->where('atendimento.local_atendimento_id', LocalAtendimento::DOMICILIO)
            ->count();

        return [
            'titulo' => 'Visitas',
            'itens' => [
                [
                    'descricao' => 'Total de número de visitas realizadas pelo SAD no período',
                    'quantidade' => $quantidadeVisitas,
                ],
            ],
            'rodape' => null
        ];
    }

    private static function getPerfilEpidemiologicoData($params)
    {
        $get = function ($perfilEpidemiologicoId) use ($params) {

            return DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
                ->join(
                    'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                    'atendimento_domiciliar.id',
                    'atendimento.atendimento_domiciliar_id'
                )
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->whereYear('atendimento_domiciliar.data', $params->ano)
                ->whereMonth('atendimento_domiciliar.data', $params->mes)
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('atencao_basica_atendimento_domiciliar_aten_perfil_epidemiologico AS atendimento_perfil')
                    ->whereColumn('atendimento_perfil.atendimento_domiciliar_atendimento_id', 'atendimento.id')
                    ->where('atendimento_perfil.perfil_epidemiologico_id', $perfilEpidemiologicoId)
                )
                ->selectRaw('COUNT(DISTINCT atendimento.paciente_id) AS quantidade')
                ->first()->quantidade ?? 0;
        };

        $quantidadeSistemaNeurologico = $get(PerfilEpidemiologico::SISTEMA_NEUROLOGICO);
        $quantidadeSistemaCardiologico = $get(PerfilEpidemiologico::SISTEMA_CARDIOLOGICO);
        $quantidadeSistemaRespiratorio = $get(PerfilEpidemiologico::SISTEMA_RESPIRATORIO);
        $quantidadeSistemaOsteoMioArticular = $get(PerfilEpidemiologico::SISTEMA_OSTEO_MIO_ARTICULAR);
        $quantidadeSistemaEndocrino = $get(PerfilEpidemiologico::SISTEMA_ENDOCRINO);
        $quantidadeSistemaTegumentar = $get(PerfilEpidemiologico::SISTEMA_TEGUMENTAR);
        $quantidadeSistemaGeniturinario = $get(PerfilEpidemiologico::SISTEMA_GENITURINARIO);
        $quantidadeOutros = $get(PerfilEpidemiologico::OUTROS);

        $quantidadeGeral = $quantidadeSistemaNeurologico
            + $quantidadeSistemaCardiologico
            + $quantidadeSistemaRespiratorio
            + $quantidadeSistemaOsteoMioArticular
            + $quantidadeSistemaEndocrino
            + $quantidadeSistemaTegumentar
            + $quantidadeSistemaGeniturinario
            + $quantidadeOutros;

        return [
            'titulo' => 'Perfil epidemiológico',
            'itens' => [
                [
                    'descricao' => 'Sistema neurológico',
                    'quantidade' => $quantidadeSistemaNeurologico,
                    'percentual' => self::getPercentual($quantidadeSistemaNeurologico, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Sistema cardiológico',
                    'quantidade' => $quantidadeSistemaCardiologico,
                    'percentual' => self::getPercentual($quantidadeSistemaCardiologico, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Sistema respiratório',
                    'quantidade' => $quantidadeSistemaRespiratorio,
                    'percentual' => self::getPercentual($quantidadeSistemaRespiratorio, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Sistema osteo-mio-articular',
                    'quantidade' => $quantidadeSistemaOsteoMioArticular,
                    'percentual' => self::getPercentual($quantidadeSistemaOsteoMioArticular, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Sistema endócrino',
                    'quantidade' => $quantidadeSistemaEndocrino,
                    'percentual' => self::getPercentual($quantidadeSistemaEndocrino, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Sistema tegumentar',
                    'quantidade' => $quantidadeSistemaTegumentar,
                    'percentual' => self::getPercentual($quantidadeSistemaTegumentar, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Sistema geniturinário',
                    'quantidade' => $quantidadeSistemaGeniturinario,
                    'percentual' => self::getPercentual($quantidadeSistemaGeniturinario, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Outros',
                    'quantidade' => $quantidadeOutros,
                    'percentual' => self::getPercentual($quantidadeOutros, $quantidadeGeral),
                ],
            ],
            'rodape' => 'Obs.: % por sistema = (Somatório de pacientes marcados naquele sistema no período x 100) ÷ '
                . '(Nº de pacientes admitidos no período no SAD)'
        ];
    }

    private static function getAtendimentosPorCategoriaData($params)
    {
        $get = function ($ocupacoesCodigos) use ($params) {

            return DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
                ->join(
                    'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                    'atendimento_domiciliar.id',
                    'atendimento.atendimento_domiciliar_id'
                )
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->join('sigtap.ocupacao AS ocupacao', 'ocupacao.id', 'atendimento_domiciliar.ocupacao_id')
                ->whereYear('atendimento_domiciliar.data', $params->ano)
                ->whereMonth('atendimento_domiciliar.data', $params->mes)
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
                ->whereIn('ocupacao.codigo', $ocupacoesCodigos)
                ->count();
        };

        $quantidadeMedica = $get(self::getCbosCategoriaMedica());
        $quantidadeEnfermagem = $get(self::getCbosCategoriaEnfermagem());
        $quantidadeFisioterapia = $get(self::getCbosCategoriaFisioterapia());
        $quantidadeNutricao = $get(self::getCbosCategoriaNutricao());
        $quantidadeFonoaudiologia = $get(self::getCbosCategoriaFonoaudiologia());
        $quantidadePsicologia = $get(self::getCbosCategoriaPsicologia());
        $quantidadeAssistenciaSocial = $get(self::getCbosCategoriaAssistenciaSocial());

        $quantidadeGeral = $quantidadeMedica
            + $quantidadeEnfermagem
            + $quantidadeFisioterapia
            + $quantidadeNutricao
            + $quantidadeFonoaudiologia
            + $quantidadePsicologia
            + $quantidadeAssistenciaSocial;

        return [
            'titulo' => 'Atendimentos por categoria',
            'itens' => [
                [
                    'descricao' => 'Médica',
                    'quantidade' => $quantidadeMedica,
                    'percentual' => self::getPercentual($quantidadeMedica, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Enfermagem',
                    'quantidade' => $quantidadeEnfermagem,
                    'percentual' => self::getPercentual($quantidadeEnfermagem, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Fisioterapia',
                    'quantidade' => $quantidadeFisioterapia,
                    'percentual' => self::getPercentual($quantidadeFisioterapia, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Nutrição',
                    'quantidade' => $quantidadeNutricao,
                    'percentual' => self::getPercentual($quantidadeNutricao, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Fonoaudiologia',
                    'quantidade' => $quantidadeFonoaudiologia,
                    'percentual' => self::getPercentual($quantidadeFonoaudiologia, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Psicologia',
                    'quantidade' => $quantidadePsicologia,
                    'percentual' => self::getPercentual($quantidadePsicologia, $quantidadeGeral),
                ],
                [
                    'descricao' => 'Assistência social',
                    'quantidade' => $quantidadeAssistenciaSocial,
                    'percentual' => self::getPercentual($quantidadeAssistenciaSocial, $quantidadeGeral),
                ],
            ],
            'rodape' => 'Obs.: % por categoria = (Nº de atendimentos realizados pela categoria x 100) ÷ '
                . '(Nº de atendimentos total no período)'
        ];
    }

    private static function getCbosCategoriaMedica()
    {
        return [
            Ocupacao::MEDICO_ACUPUNTURISTA,
            Ocupacao::MEDICO_ANGIOLOGISTA,
            Ocupacao::MEDICO_ANTROPOSOFICO,
            Ocupacao::MEDICO_CARDIOLOGISTA,
            Ocupacao::MEDICO_CIRURGIAO_CARDIOVASCULAR,
            Ocupacao::MEDICO_CIRURGIAO_GERAL,
            Ocupacao::MEDICO_CIRURGIAO_PEDIATRICO,
            Ocupacao::MEDICO_CLINICO,
            Ocupacao::MEDICO_DA_ESTRATEGIA_DE_SAUDE_DA_FAMILIA,
            Ocupacao::MEDICO_DE_FAMILIA_E_COMUNIDADE,
            Ocupacao::MEDICO_DERMATOLOGISTA,
            Ocupacao::MEDICO_DO_TRABALHO,
            Ocupacao::MEDICO_EM_CIRURGIA_VASCULAR,
            Ocupacao::MEDICO_EM_MEDICINA_INTENSIVA,
            Ocupacao::MEDICO_EM_MEDICINA_PREVENTIVA_E_SOCIAL,
            Ocupacao::MEDICO_EM_RADIOLOGIA_E_DIAGNOSTICO_POR_IMAGEM,
            Ocupacao::MEDICO_ENDOCRINOLOGISTA_E_METABOLOGISTA,
            Ocupacao::MEDICO_FISIATRA,
            Ocupacao::MEDICO_GASTROENTEROLOGISTA,
            Ocupacao::MEDICO_GENERALISTA,
            Ocupacao::MEDICO_GERIATRA,
            Ocupacao::MEDICO_GINECOLOGISTA_E_OBSTETRA,
            Ocupacao::MEDICO_HANSENOLOGISTA,
            Ocupacao::MEDICO_HOMEOPATA,
            Ocupacao::MEDICO_INFECTOLOGISTA,
            Ocupacao::MEDICO_MASTOLOGISTA,
            Ocupacao::MEDICO_NEUROCIRURGIAO,
            Ocupacao::MEDICO_NEUROFISIOLOGISTA_CLINICO,
            Ocupacao::MEDICO_NEFROLOGISTA,
            Ocupacao::MEDICO_NEUROLOGISTA,
            Ocupacao::MEDICO_OFTALMOLOGISTA,
            Ocupacao::MEDICO_ORTOPEDISTA_E_TRAUMATOLOGISTA,
            Ocupacao::MEDICO_OTORRINOLARINGOLOGISTA,
            Ocupacao::MEDICO_PEDIATRA,
            Ocupacao::MEDICO_PNEUMOLOGISTA,
            Ocupacao::MEDICO_PSIQUIATRA,
            Ocupacao::MEDICO_REUMATOLOGISTA,
            Ocupacao::MEDICO_RESIDENTE,
            Ocupacao::MEDICO_SANITARISTA,
            Ocupacao::MEDICO_UROLOGISTA,
        ];
    }

    private static function getCbosCategoriaEnfermagem()
    {
        return [
            Ocupacao::ENFERMEIRO,
            Ocupacao::ENFERMEIRO_AUDITOR,
            Ocupacao::ENFERMEIRO_DA_ESTRATEGIA_DE_SAUDE_DA_FAMILIA,
            Ocupacao::ENFERMEIRO_DO_TRABALHO,
            Ocupacao::ENFERMEIRO_OBSTETRICO,
            Ocupacao::ENFERMEIRO_PSIQUIATRICO,
            Ocupacao::ENFERMEIRO_PUERICULTOR_E_PEDIATRICO,
            Ocupacao::ENFERMEIRO_SANITARISTA,
        ];
    }

    private static function getCbosCategoriaFisioterapia()
    {
        return [
            Ocupacao::FISIOTERAPEUTA_ACUPUNTURISTA,
            Ocupacao::FISIOTERAPEUTA_DO_TRABALHO,
            Ocupacao::FISIOTERAPEUTA_ESPORTIVO,
            Ocupacao::FISIOTERAPEUTA_GERAL,
            Ocupacao::FISIOTERAPEUTA_NEUROFUNCIONAL,
            Ocupacao::FISIOTERAPEUTA_TRAUMATOORTOPEDICA_FUNCIONAL,
        ];
    }

    private static function getCbosCategoriaNutricao()
    {
        return [
            Ocupacao::NUTRICIONISTA,
        ];
    }

    private static function getCbosCategoriaFonoaudiologia()
    {
        return [
            Ocupacao::FONOAUDIOLOGO,
            Ocupacao::FONOAUDIOLOGO_EDUCACIONAL,
            Ocupacao::FONOAUDIOLOGO_EM_LINGUAGEM,
            Ocupacao::FONOAUDIOLOGO_EM_SAUDE_COLETIVA,
        ];
    }

    private static function getCbosCategoriaPsicologia()
    {
        return [
            Ocupacao::PSICOLOGO_ACUPUNTURISTA,
            Ocupacao::PSICOLOGO_CLINICO,
            Ocupacao::PSICOLOGO_DO_TRABALHO,
            Ocupacao::PSICOLOGO_EDUCACIONAL,
            Ocupacao::PSICOLOGO_HOSPITALAR,
            Ocupacao::PSICOLOGO_JURIDICO,
            Ocupacao::PSICOLOGO_SOCIAL,
        ];
    }

    private static function getCbosCategoriaAssistenciaSocial()
    {
        return [
            Ocupacao::ASSISTENTE_SOCIAL,
        ];
    }

    private static function getDadosEpidemiologicosGeraisData($params)
    {
        $get = function ($perfilEpidemiologicoId) use ($params) {

            return DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
                ->join(
                    'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                    'atendimento_domiciliar.id',
                    'atendimento.atendimento_domiciliar_id'
                )
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->whereYear('atendimento_domiciliar.data', $params->ano)
                ->whereMonth('atendimento_domiciliar.data', $params->mes)
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('atencao_basica_atendimento_domiciliar_aten_perfil_epidemiologico AS atendimento_perfil')
                    ->whereColumn('atendimento_perfil.atendimento_domiciliar_atendimento_id', 'atendimento.id')
                    ->where('atendimento_perfil.perfil_epidemiologico_id', $perfilEpidemiologicoId)
                )
                ->selectRaw('COUNT(DISTINCT atendimento.paciente_id) AS quantidade')
                ->first()->quantidade ?? 0;
        };

        $quantidadeOxigenoterapiaDomiciliar = DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
            ->join(
                'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                'atendimento_domiciliar.id',
                'atendimento.atendimento_domiciliar_id'
            )
            ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
            ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
            ->whereYear('atendimento_domiciliar.data', $params->ano)
            ->whereMonth('atendimento_domiciliar.data', $params->mes)
            ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
            ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
            ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('atencao_basica_atendimento_domiciliar_condicao AS atendimento_condicao')
                ->whereColumn('atendimento_condicao.atendimento_id', 'atendimento.id')
                ->where('atendimento_condicao.condicao_id', CondicaoAvaliada::OXIGENOTERAPIA_DOMICILIAR)
            )
            ->selectRaw('COUNT(DISTINCT atendimento.paciente_id) AS quantidade')
            ->first()->quantidade ?? 0;

        $quantidadeInternacaoHospitalar = DB::table('atencao_basica_atendimento_domiciliar_atendimento AS atendimento')
            ->join(
                'atencao_basica_atendimento_domiciliar AS atendimento_domiciliar',
                'atendimento_domiciliar.id',
                'atendimento.atendimento_domiciliar_id'
            )
            ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'atendimento_domiciliar.equipe_id')
            ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
            ->whereYear('atendimento_domiciliar.data', $params->ano)
            ->whereMonth('atendimento_domiciliar.data', $params->mes)
            ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
            ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
            ->when($params->equipe_id, fn ($q, $id) => $q->where('atendimento_domiciliar.equipe_id', $id))
            ->where('atendimento.conduta_desfecho_id', CondutaDesfecho::SERVICO_DE_INTERNACAO_HOSPITALAR)
            ->selectRaw('COUNT(DISTINCT atendimento.paciente_id) AS quantidade')
            ->first()->quantidade ?? 0;

        $quantidadeFazendoUsoDietasEspeciais = $get(PerfilEpidemiologico::USO_DE_DIETAS_ESPECIAIS);
        $quantidadeFazendoUsoEspessante = $get(PerfilEpidemiologico::USO_DE_ESPESSANTE);
        $quantidadeSeEntregaMaterial = $get(PerfilEpidemiologico::ENTREGA_DE_MATERIAIS);
        $quantidadeApenasSeEntregaMateriais = $get(PerfilEpidemiologico::ENTREGA_DE_MATERIAIS);
        $quantidadeAvaliacaoProcesso = $get(PerfilEpidemiologico::AVALIACAO_DE_PROCESSO);
        $quantidadeAdquiriramInfecaoDomiciliar = $get(PerfilEpidemiologico::ADQUIRIU_INFECCAO_DOMICILIAR);
        $quantidadeAreaRisco = $get(PerfilEpidemiologico::RESIDENTE_EM_AREA_DE_RISCO);

        return [
            'titulo' => 'Dados epidemiológicos gerais',
            'itens' => [
                [
                    'descricao' => 'Nº de pacientes fazendo uso de dietas especiais',
                    'quantidade' => $quantidadeFazendoUsoDietasEspeciais,
                ],
                [
                    'descricao' => 'Nº de pacientes fazendo uso de espessante',
                    'quantidade' => $quantidadeFazendoUsoEspessante,
                ],
                [
                    'descricao' => 'Nº de pacientes aos quais se entrega material',
                    'quantidade' => $quantidadeSeEntregaMaterial,
                ],
                [
                    'descricao' => 'Nº de pacientes aos quais apenas se entrega materiais',
                    'quantidade' => $quantidadeApenasSeEntregaMateriais,
                ],
                [
                    'descricao' => 'Nº de pacientes de avaliação de processo',
                    'quantidade' => $quantidadeAvaliacaoProcesso,
                ],
                [
                    'descricao' => 'Nº de pacientes de oxigenoterapia domiciliar',
                    'quantidade' => $quantidadeOxigenoterapiaDomiciliar,
                ],
                [
                    'descricao' => 'Nº de internação hospitalar',
                    'quantidade' => $quantidadeInternacaoHospitalar,
                ],
                [
                    'descricao' => 'Nº de pacientes que adquiriram infecção domiciliar',
                    'quantidade' => $quantidadeAdquiriramInfecaoDomiciliar,
                ],
                [
                    'descricao' => 'Nº de pacientes residentes em área de risco',
                    'quantidade' => $quantidadeAreaRisco,
                ],
            ],
            'rodape' => 'Obs.: Quantidade = contagem total de marcações por item no período'
        ];
    }

    private static function getPercentual($quantidade, $quantidadeGeral)
    {
        if ($quantidadeGeral === 0) {

            return 0;
        }

        $percentual = ($quantidade * 100) / $quantidadeGeral;

        if (is_int($percentual)) {

            return $percentual;
        }

        $percentualTruncado = floor($percentual * 10) / 10;

        if (fmod($percentualTruncado, 1) == 0) {

            return (int) $percentualTruncado;
        }

        return number_format($percentualTruncado, 1, ',', '.');
    }

    public static function list()
    {
        $data = (object) [
            'form' => [],
            'model' => [],
        ];

        $params = self::getParams();

        $sets = [
            'ano' => function () use ($data, $params) {

                $anosData = self::getAnosData();

                $data->form['anos'] = $anosData['form'];
                $data->model['ano'] = $anosData['model'];

                $params->ano = $data->model['ano'];
            },
            'mes' => function () use ($data, $params) {

                $mesesData = self::getMesesData($params);

                $data->form['meses'] = $mesesData['form'];
                $data->model['mes'] = $mesesData['model'];

                $params->mes = $data->model['mes'];
            },
            'unidade' => function () use ($data, $params) {

                $unidadesData = self::getUnidadesData($params);

                $data->form['unidades'] = $unidadesData['form'];
                $data->model['unidade_id'] = $unidadesData['model'];

                $params->unidade_id = $data->model['unidade_id'];
            },
            'infraestrutura' => function () use ($data, $params) {

                $infraestruturasData = self::getInfraestruturasData($params);

                $data->form['infraestruturas'] = $infraestruturasData['form'];
                $data->model['infraestrutura_id'] = $infraestruturasData['model'];

                $params->infraestrutura_id = $data->model['infraestrutura_id'];
            },
            'equipe' => function () use ($data, $params) {

                $equipesData = self::getEquipesData($params);

                $data->form['equipes'] = $equipesData['form'];
                $data->model['equipe_id'] = $equipesData['model'];

                $params->equipe_id = $data->model['equipe_id'];
            },
        ];

        $load = is_null(request()->load_from);

        foreach ($sets as $field => $set) {

            if ($load) {

                $set();
            }
            else if ($field === request()->load_from) {

                $load = true;
            }
        }

        foreach ($data as $property => $itens) {

            if (empty($itens)) {

                unset($data->{$property});
            }
        }

        return $data;
    }

    private static function getParams()
    {
        return (object) request()->only([
            'ano',
            'mes',
            'unidade_id',
            'infraestrutura_id',
            'equipe_id',
        ]);
    }

    private static function getAnosData()
    {
        $anos = DB::table('atencao_basica_atendimento_domiciliar AS atendimento_domiciliar')
            ->select(
                DB::raw('EXTRACT(YEAR FROM atendimento_domiciliar.data) AS ano')
            )
            ->distinct()
            ->union(DB::table('atencao_basica_avaliacao AS avaliacao')
                ->select(
                    DB::raw('EXTRACT(YEAR FROM avaliacao.data) AS ano')
                )
                ->distinct()
            )
            ->orderByDesc('ano')
            ->get()
            ->map(fn ($a) => (object) ['value' => $a->ano, 'text' => $a->ano]);

        return ['form' => $anos, 'model' => null];
    }

    private static function getMesesData($params)
    {
        $meses = collect();

        if (!is_null($params->ano)) {

            $meses = DB::table('atencao_basica_atendimento_domiciliar AS atendimento_domiciliar')
                ->whereRaw('EXTRACT(YEAR FROM atendimento_domiciliar.data) = ?', [$params->ano])
                ->select(
                    DB::raw('EXTRACT(MONTH FROM atendimento_domiciliar.data) AS mes')
                )
                ->distinct()
                ->union(DB::table('atencao_basica_avaliacao AS avaliacao')
                    ->whereRaw('EXTRACT(YEAR FROM avaliacao.data) = ?', [$params->ano])
                    ->select(
                        DB::raw('EXTRACT(MONTH FROM avaliacao.data) AS mes')
                    )
                    ->distinct()
                )
                ->orderBy('mes')
                ->get()
                ->map(fn ($mes) => (object) [
                    'value' => $mes->mes,
                    'text' => Str::ucfirst(Carbon::create()->month((int) $mes->mes)->translatedFormat('F')),
                ]);
        }

        return ['form' => $meses, 'model' => null];
    }

    private static function getUnidadesData($params)
    {
        $unidades = collect();

        if (!is_null($params->mes)) {

            $unidades = DB::table('cadastro_unidade AS unidade')
                ->whereNull('unidade.deleted_at')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('cadastro_infraestrutura AS infraestrutura')
                    ->whereColumn('infraestrutura.unidade_id', 'unidade.id')
                    ->whereNull('infraestrutura.deleted_at')
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('atencao_basica_parametrizacao_equipe AS equipe')
                        ->whereColumn('equipe.infraestrutura_id', 'infraestrutura.id')
                        ->where(fn ($q) => $q
                            ->whereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('atencao_basica_atendimento_domiciliar AS atendimento_domiciliar')
                                ->whereColumn('atendimento_domiciliar.equipe_id', 'equipe.id')
                                ->whereRaw('EXTRACT(YEAR FROM atendimento_domiciliar.data) = ?', [$params->ano])
                                ->whereRaw('EXTRACT(MONTH FROM atendimento_domiciliar.data) = ?', [$params->mes])
                            )
                            ->orWhereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('atencao_basica_avaliacao AS avaliacao')
                                ->whereColumn('avaliacao.equipe_id', 'equipe.id')
                                ->whereRaw('EXTRACT(YEAR FROM avaliacao.data) = ?', [$params->ano])
                                ->whereRaw('EXTRACT(MONTH FROM avaliacao.data) = ?', [$params->mes])
                            )
                        )
                    )
                )
                ->select(
                    'unidade.id',
                    'unidade.nome_fantasia'
                )
                ->orderBy('unidade.nome_fantasia')
                ->get();
        }

        return ['form' => $unidades, 'model' => null];
    }

    private static function getInfraestruturasData($params)
    {
        $infraestruturas = collect();

        if (!is_null($params->unidade_id)) {

            $infraestruturas = DB::table('cadastro_infraestrutura AS infraestrutura')
                ->join('cadastro_unidade AS unidade', 'unidade.id', 'infraestrutura.unidade_id')
                ->whereNull('infraestrutura.deleted_at')
                ->whereNull('unidade.deleted_at')
                ->where('infraestrutura.unidade_id', $params->unidade_id)
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('atencao_basica_parametrizacao_equipe AS equipe')
                    ->whereColumn('equipe.infraestrutura_id', 'infraestrutura.id')
                    ->where(fn ($q) => $q
                        ->whereExists(fn ($q) => $q
                            ->selectRaw(1)
                            ->from('atencao_basica_atendimento_domiciliar AS atendimento_domiciliar')
                            ->whereColumn('atendimento_domiciliar.equipe_id', 'equipe.id')
                            ->whereRaw('EXTRACT(YEAR FROM atendimento_domiciliar.data) = ?', [$params->ano])
                            ->whereRaw('EXTRACT(MONTH FROM atendimento_domiciliar.data) = ?', [$params->mes])
                        )
                        ->orWhereExists(fn ($q) => $q
                            ->selectRaw(1)
                            ->from('atencao_basica_avaliacao AS avaliacao')
                            ->whereColumn('avaliacao.equipe_id', 'equipe.id')
                            ->whereRaw('EXTRACT(YEAR FROM avaliacao.data) = ?', [$params->ano])
                            ->whereRaw('EXTRACT(MONTH FROM avaliacao.data) = ?', [$params->mes])
                        )
                    )
                )
                ->select(
                    'infraestrutura.id',
                    DB::raw('COALESCE(infraestrutura.nome, unidade.nome_fantasia) AS nome')
                )
                ->orderByRaw('COALESCE(infraestrutura.nome, unidade.nome_fantasia)')
                ->get();
        }

        return ['form' => $infraestruturas, 'model' => null];
    }

    private static function getEquipesData($params)
    {
        $equipes = collect();

        if (!is_null($params->infraestrutura_id)) {

            $equipes = DB::table('atencao_basica_parametrizacao_equipe AS equipe')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                ->join('atencao_basica_parametrizacao_area AS area', 'area.id', 'equipe.area_id')
                ->leftJoin('atencao_basica_parametrizacao_microarea AS microarea', 'microarea.id', 'equipe.microarea_id')
                ->whereNull('infraestrutura.deleted_at')
                ->where('infraestrutura.unidade_id', $params->unidade_id)
                ->where('equipe.infraestrutura_id', $params->infraestrutura_id)
                ->where(fn ($q) => $q
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('atencao_basica_atendimento_domiciliar AS atendimento_domiciliar')
                        ->whereColumn('atendimento_domiciliar.equipe_id', 'equipe.id')
                        ->whereRaw('EXTRACT(YEAR FROM atendimento_domiciliar.data) = ?', [$params->ano])
                        ->whereRaw('EXTRACT(MONTH FROM atendimento_domiciliar.data) = ?', [$params->mes])
                    )
                    ->orWhereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('atencao_basica_avaliacao AS avaliacao')
                        ->whereColumn('avaliacao.equipe_id', 'equipe.id')
                        ->whereRaw('EXTRACT(YEAR FROM avaliacao.data) = ?', [$params->ano])
                        ->whereRaw('EXTRACT(MONTH FROM avaliacao.data) = ?', [$params->mes])
                    )
                )
                ->select(
                    'equipe.id',
                    DB::raw("CONCAT(
                        IF(area.numero_ine IS NULL, '', CONCAT('INE: ', area.numero_ine)),
                        IF(area.descricao IS NULL, '', CONCAT(' - Área: ', area.descricao)),
                        IF(microarea.descricao IS NULL, '', CONCAT(' - Microárea: ', microarea.descricao))
                    ) AS descricao")
                )
                ->orderByRaw('descricao')
                ->get();

            $equipes->each(function ($equipe) {

                $equipe->descricao = trim(trim($equipe->descricao), '-');
            });
        }

        return ['form' => $equipes, 'model' => null];
    }

    public static function getPrintExportData()
    {
        $resultado = self::index();
        $params = self::getParams();

        $unidade = is_null($params->unidade_id) ? null : Unidade::find($params->unidade_id);
        $infraestrutura = is_null($params->infraestrutura_id) ? null : Infraestrutura::find($params->infraestrutura_id);
        $equipe = is_null($params->equipe_id) ? null : Equipe::find($params->equipe_id);

        return [
            'ano' => $params->ano,
            'mes' => Str::ucfirst(Carbon::create()->month((int) $params->mes)->translatedFormat('F')),
            'unidade' => $unidade->nome_fantasia ?? 'Todas',
            'infraestrutura' => $infraestrutura->nome ?? 'Todos',
            'equipe' => is_null($equipe) ? 'Todas' : self::getDescricaoEquipe($equipe),
            'resultado' => $resultado,
        ];
    }

    private static function getDescricaoEquipe($equipe)
    {
        $descricao = '';

        if (!empty($equipe->area->numero_ine)) {

            $descricao .= "INE: {$equipe->area->numero_ine}";
        }

        if (!empty($equipe->area->descricao)) {

            $descricao .= " - Área: {$equipe->area->descricao}";
        }

        if (!empty($equipe->microarea->descricao)) {

            $descricao .= " - Microárea: {$equipe->microarea->descricao}";
        }

        return trim(trim($descricao), '-');
    }
}