<?php

namespace App\Services\ProntoAtendimento;

use App\Enums\Cadastro\SujeitoAtencao\FatorRisco as EnumFatorRisco;
use App\Enums\Cadastro\UnidadeMedida as CadastroUnidadeMedida;
use App\Enums\Parametrizacao\Exame\Status;
use App\Enums\Parametrizacao\Exame\Tipo as ExameTipo;
use App\Enums\ProntoAtendimento\Atendimento\Desfecho;
use App\Enums\ProntoAtendimento\Atendimento\DorToracica as DorToracicaEnum;
use App\Enums\ProntoAtendimento\Atendimento\PacienteTraumaStatus;
use App\Enums\ProntoAtendimento\Raat\CausaAcidente;
use App\Enums\ProntoAtendimento\Raat\Diagnostico as DiagnosticoRaat;
use App\Enums\ProntoAtendimento\Raat\ParteCorpoAtingida;
use App\Enums\ProntoAtendimento\TipoFormularioAcidenteTrabalho;
use App\Models\Cadastro\SujeitoAtencao\Lotacao;
use App\Models\Cadastro\UnidadeMedida;
use App\Models\Geral\GlasgowInterpretacaoResultado;
use App\Models\ProntoAtendimento\Atendimento\Atendimento;
use App\Models\ProntoAtendimento\Atendimento\Cat;
use App\Models\ProntoAtendimento\Atendimento\FaaReabertura;
use App\Models\ProntoAtendimento\Atendimento\PrescricaoInterna;
use App\Models\ProntoAtendimento\Atendimento\Triagem\FormularioDorToracica;
use App\Models\ProntoAtendimento\Atendimento\Triagem\OrigemDorToracica;
use App\Models\ProntoAtendimento\Atendimento\Triagem\RelacionadoFormularioDorToracica;
use App\Models\Sigtap\Cid;
use App\Models\Sigtap\Ocupacao;
use App\Models\Sigtap\Procedimento;
use App\Services\Service;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class HistoricoService extends Service
{
    public static function getHistoricoResumido($filters, $options = [])
    {
        return Atendimento::whereHas('faa', fn ($q) => $q->where('paciente_id', $filters['paciente_id']))
            ->orderBy('created_at')
            ->get()
            ->map(function ($atendimento) use ($options) {

                $atendimento = $atendimento->faa->atendimentos->sortByDesc('created_at')->first();

                $hasAtendimento = $atendimento
                    ->where(fn ($q) => $q
                        ->whereHas('atendimentosTriagem')
                        ->orWhereHas('atendimentosMedico')
                        ->orWhereHas('atendimentosEnfermagem')
                        ->orWhereHas('pedidosExames')
                        ->orWhereHas('pacienteObservacoes')
                    )
                    ->where('id', $atendimento->id)
                    ->exists();

                if (!$hasAtendimento) {

                    $procedimentoPadrao = $atendimento->procedimentos->where('is_parametrizado', true)->last();

                    $lotacaoProfissionalResponsavel = $procedimentoPadrao->lotacao ?? null;
                }
                else {

                    $firstAtendimentoMedico = $atendimento->atendimentosMedico->first();

                    $lotacaoProfissionalResponsavel = $firstAtendimentoMedico->createdLotacao ?? null;
                }

                return (object) [
                    'id' => $atendimento->id,
                    'data_hora' => !isset($options['format_date_time']) || $options['format_date_time']
                        ? (new Carbon($atendimento->recepcao->atendido_em))->format('d/m/Y H:i')
                        : new Carbon($atendimento->recepcao->atendido_em),
                    'lotacao' => [
                        'ocupacao' => [
                            'codigo' => $lotacaoProfissionalResponsavel ? $lotacaoProfissionalResponsavel->ocupacao->codigo : ($atendimento->faa->lotacao->ocupacao->codigo ?? null),
                            'nome' => $lotacaoProfissionalResponsavel ? $lotacaoProfissionalResponsavel->ocupacao->nome : ($atendimento->faa->lotacao->ocupacao->nome ?? null),
                        ],
                        'profissional' => [
                            'nome' => !empty($lotacaoProfissionalResponsavel->usuario->cidadao) ? $lotacaoProfissionalResponsavel->usuario->cidadao->nome : ($atendimento->faa->usuario->cidadao->nome ?? null),
                        ],
                    ],
                    'centro_custo' => [
                        'unidade' => [
                            'nome_fantasia' => $lotacaoProfissionalResponsavel ? $lotacaoProfissionalResponsavel->infraestrutura->unidade->nome_fantasia : ($atendimento->faa->lotacao->infraestrutura->unidade->nome_fantasia ?? null),
                        ],
                    ],
                ];
            });
    }

    public static function getAtendimento($atendimentoId)
    {
        $atendimento = Atendimento::withTrashed()->findOrFail($atendimentoId);
        $recepcao = $atendimento->recepcao;
        $atendimentosData = self::getAtendimentosData($atendimento);

        $lastAtendimentoDateTime = empty($atendimentosData)
            ? new Carbon($atendimento->recepcao->created_at)
            : Carbon::createFromFormat(
                'd/m/Y H:i:s',
                $atendimentosData[count($atendimentosData) - 1]['data_hora']
            );

        $latestCreatedAt = DB::table('cadastro_cidadao_fator_risco')
            ->where('cidadao_id', $atendimento->faa->paciente->cidadao->id)
            ->max('created_at');

        if ($atendimento->dor_toracica == true) {

            $formulario = FormularioDorToracica::where('atendimento_id', $atendimento->id)->get();

            $data_sintoma = null;
            $hora_sintoma = null;
            $data_ecg_admissao = null;
            $hora_ecg_admissao = null;
            $dispneia = null;

            foreach ($formulario as $registro) {
                $data_sintoma = $registro->data_sintoma ?? null;
                $hora_sintoma = $registro->hora_sintoma ?? null;
                $data_ecg_admissao = $registro->data_ecg_admissao ?? null;
                $hora_ecg_admissao = $registro->hora_ecg_admissao ?? null;
                $dispneia = $registro->dispneia ?? null;
            }

            if (!empty($formulario)) {
                $formulario_id = $formulario->pluck('id');
                $formularioRelacionadoDor = RelacionadoFormularioDorToracica::whereIn('formulario_id', $formulario_id)->get();

                $dorToracicaRelacionada = [];

                foreach ($formularioRelacionadoDor as $registroRelacionado) {
                    $dorToracicaRelacionada[] = OrigemDorToracica::where('id', $registroRelacionado->dor_toracica_id)
                        ->get()
                        ->map(function ($duracao) {
                            return [
                                'id' => $duracao->id,
                                'nome' => $duracao->nome,
                            ];
                        })->values();
                }
            }
        }

        return (object) [
            'unidade' => $atendimento->faa->lotacao->infraestrutura->unidade->nome_fantasia ?? null,
            'dataHoraEntrada' => (new Carbon($atendimento->recepcao->atendido_em))->format('d/m/Y H:i:s'),
            'recepcionista' => $recepcao->createdLotacao->usuario->cidadao->nome ?? 'NÃO INFORMADO',
            'origemEntrada' => $atendimento->recepcao->origemEntrada->nome ?? 'NÃO INFORMADA',
            'especialidade' => $atendimento->recepcao->ocupacao->nome ?? 'NÃO INFORMADA',
            'medicoSamu' => $atendimento->recepcao->medico_samu ?? 'NÃO INFORMADO',
            'senha' => $atendimento->fila->senha ?? null,
            'motivoAtendimento' => $atendimento->recepcao->motivo_atendimento ?? 'NÃO INFORMADO',
            'paciente' => self::getPacienteData($atendimento),
            'raat' => self::getRaatData($atendimento),
            'classificacoesRisco' => self::getClassificacoesRiscoData($atendimento),
            'fatoresRisco' => self::getFatoresRiscoData($atendimento, $latestCreatedAt),
            'alergias' => self::getAlergiasData($atendimento, $lastAtendimentoDateTime),
            'medicamentosUsoContinuo' => self::getMedicamentosUsoContinuoData($atendimento, $lastAtendimentoDateTime),
            'medicamentosEmUso' => self::getMedicamentosEmUsoData($atendimento),
            'atendimentos' => $atendimentosData,
            'desfecho' => self::getDesfechoData($atendimento),
            'assistenciaSocial' => self::getAssistenciaData($atendimento),
            'dorToracica' => $atendimento->dor_toracica,
            'formularioDorToracica' => [
                'data_sintoma' => isset($data_sintoma) ? (new Carbon($data_sintoma))->format('d/m/Y') : null,
                'hora_sintoma' => isset($hora_sintoma) ? (new Carbon($hora_sintoma ))->format('H:i:s') : null,
                'data_ecg_admissao' => isset($data_ecg_admissao) ? (new Carbon($data_ecg_admissao))->format('d/m/Y') : null,
                'hora_ecg_admissao' => isset($hora_ecg_admissao) ? (new Carbon($hora_ecg_admissao))->format('H:i:s') : null,
                'dispneia' => $dispneia ?? null,
                'relacionados' => isset($dorToracicaRelacionada) ? self::getDorToracicaRelacionados($dorToracicaRelacionada) : null,
            ],
            'exclusaoFaa'=> self::getFaaCancelada($atendimento),
        ];
    }

    private static function getDorToracicaRelacionados($relacionados)
    {
        return [
            'caracteristicas_da_dor' => self::getDorToracicaCaracteristicasDaDor($relacionados),
            'localizadores_da_dor' => self::getDorToracicaLocalizadorDaDor($relacionados),
            'fatores_desencadeantes' => self::getDorToracicaFatorDesencadeante($relacionados),
            'duracao_da_dor' => self::getDorToracicaDuracaoDaDor($relacionados),
            'fatores_de_risco' => self::getDorToracicaFatoresDeRisco($relacionados),
        ];
    }

    private static function getDorToracicaCaracteristicasDaDor($relacionados)
    {
        $statusEnum = [
            DorToracicaEnum::CONTRICAO,
            DorToracicaEnum::QUEIMACAO,
            DorToracicaEnum::COMPRESSAO,
            DorToracicaEnum::PESO,
            DorToracicaEnum::DOR_SURDA
        ];

        $caracteristicasDor = [];

        foreach ($relacionados as $caracteristica) {
            foreach ($caracteristica as $item) {
                if (in_array($item['id'], $statusEnum)) {
                    $caracteristicasDor[] = $item['nome'];
                }
            }
        }

        sort($caracteristicasDor);

        return $caracteristicasDor;
    }

    private static function getDorToracicaLocalizadorDaDor($relacionados)
    {
        $statusEnum = [
            DorToracicaEnum::RETROESTERNAL,
            DorToracicaEnum::MSE,
            DorToracicaEnum::FACE,
            DorToracicaEnum::PESCOCO,
            DorToracicaEnum::DENTES,
            DorToracicaEnum::INTER_ESCAPULAR,
            DorToracicaEnum::EPIGASTRICA,
        ];

        $localizadoresDor = [];

        foreach ($relacionados as $localizador) {
            foreach ($localizador as $item) {
                if (in_array($item['id'], $statusEnum)) {
                    $localizadoresDor[] = $item['nome'];
                }
            }
        }

        sort($localizadoresDor);

        return $localizadoresDor;
    }

    private static function getDorToracicaFatorDesencadeante($relacionados)
    {
        $statusEnum = [
            DorToracicaEnum::EXERCICIO,
            DorToracicaEnum::EXCITACAO,
            DorToracicaEnum::ESTRESSE,
            DorToracicaEnum::FRIO,
            DorToracicaEnum::REFEICOES_COPIOSAS,
        ];

        $fatoresDesencadeantes = [];

        foreach ($relacionados as $desencadeante) {
            foreach ($desencadeante as $item) {
                if (in_array($item['id'], $statusEnum)) {
                    $fatoresDesencadeantes[] = $item['nome'];
                }
            }
        }

        sort($fatoresDesencadeantes);

        return $fatoresDesencadeantes;
    }

    private static function getDorToracicaDuracaoDaDor($relacionados)
    {
        $hasLongerThan5Minutes = false;
        $hasDurationInfo = false;

        foreach ($relacionados as $duracaoDor) {
            foreach ($duracaoDor as $item) {
                $statusEnum = [
                    DorToracicaEnum::DURACAO_DA_DOR,
                ];

                if (in_array($item['id'], $statusEnum)) {
                    $hasLongerThan5Minutes = true;
                    $hasDurationInfo = true;
                }
            }
        }

        return compact('hasDurationInfo', 'hasLongerThan5Minutes');
    }

    private static function getDorToracicaFatoresDeRisco($relacionados)
    {
        $statusEnum = [
            DorToracicaEnum::HAS,
            DorToracicaEnum::DM,
            DorToracicaEnum::DISLIPIDEMIA,
            DorToracicaEnum::HISTORIA_FAMILIAR,
            DorToracicaEnum::IDADE_MAIOR_SESSENTA,
            DorToracicaEnum::OBESIDADE,
            DorToracicaEnum::TABAGISMO,
            DorToracicaEnum::REVASCULARIZADO_PREVIO,
        ];

        $fatoresRiscoOrdenados = [];

        foreach ($relacionados as $fatorRisco) {
            foreach ($fatorRisco as $item) {
                if (in_array($item['id'], $statusEnum)) {
                    if ($item['id'] === DorToracicaEnum::IDADE_MAIOR_SESSENTA) {
                        $fatoresRiscoOrdenados[] = '- Idade > 60 anos';
                    } else {
                        $fatoresRiscoOrdenados[] = '- ' . $item['nome'];
                    }
                }
            }
        }

        sort($fatoresRiscoOrdenados);

        return $fatoresRiscoOrdenados;
    }

    private static function getFaaCancelada($atendimento)
    {

        $faa = $atendimento->faa;

        if (is_null($faa->deleted_at)) {

            return null;
        }

        return [
            'data_hora' => $faa->deleted_at
                ? (new Carbon($faa->deleted_at))->format('d/m/Y H:i:s')
                : '',
            'profissional' => Lotacao::find($faa->deleted_lotacao_id)->usuario->cidadao->nome ?? '',
            'cbo' => Lotacao::find($faa->deleted_lotacao_id)->ocupacao->nome ?? '',
        ];
    }

    private static function getAssistenciaData($atendimento)
    {
        return $atendimento->assistenciaSocialHistorico()
            ->orderBy('created_at', 'desc')
            ->get()
            ->map(fn ($assistencia) => [
                'data' => (new Carbon($assistencia->created_at))->format('d/m/Y') ?? null,
                'horario' => (new Carbon($assistencia->created_at))->format('H:i:s') ?? null,
                'anotacao' => $assistencia->anotacao,
                'profissional' => [
                    'id' => $assistencia->usuario->id,
                    'nome' => $assistencia->usuario->cidadao->nome,
                ],
                'cbo' => Ocupacao::findOrFail($assistencia['ocupacao_id'])->nome,
            ])->all();
    }

    private static function getAtendimentosData($atendimento)
    {
        $cidAnterior = null;
        $dataHoraEntradaObservacao = null;

        return collect(array_merge(
            self::getAtendimentosTriagemData($atendimento->atendimentosTriagem),
            self::getAtendimentosMedicosData($atendimento->atendimentosMedico),
            self::getAtendimentosEnfermagemData($atendimento->atendimentosEnfermagem),
            self::getAtendimentosExameImagemData($atendimento->atendimentosExameImagem),
            self::getAtendimentosObservacaoData($atendimento->pacienteObservacoes),
            self::getProcedimentosFechamentoData($atendimento),
            self::getAssistenciaSocialData($atendimento->assistenciaSocial),
            self::getFaaReaberturaData($atendimento),
        ))
            ->sortBy('data_hora')
            ->values()
            ->map(function ($atendimento) use (&$cidAnterior, &$dataHoraEntradaObservacao, &$isObservacao) {

                $atendimento['data_hora'] = $atendimento['data_hora']->format('d/m/Y H:i:s');

                if ($atendimento['tipo'] === 'medico') {

                    $currentCid = $atendimento['cid'];

                    if ($atendimento['cid'] === $cidAnterior) {

                        $atendimento['cid'] = null;
                    }

                    $cidAnterior = $currentCid;
                }
                else if ($atendimento['tipo'] === 'observacao') {

                    if (is_null($dataHoraEntradaObservacao)) {

                        $dataHoraEntradaObservacao = $atendimento['data_hora'];
                    }

                    $atendimento['data_hora_entrada'] = $dataHoraEntradaObservacao;
                }

                return $atendimento;
            })
            ->all();
    }

    private static function getAssistenciaSocialData($assistenciaSocial)
    {
        return $assistenciaSocial->map(fn ($atendimento) => [
            'tipo' => 'assistencia',
            'id' => $atendimento->id,
            'data_hora' => $atendimento->created_at,
            'profissional' => [
                'id' => $atendimento->usuario->id,
                'nome' => $atendimento->usuario->cidadao->nome,
            ],
            'cbo' => Ocupacao::findOrFail($atendimento['ocupacao_id'])->nome,
        ])->all();
    }

    private static function getFaaReaberturaData($reabertura)
    {

        $faaReaberta = FaaReabertura::where('faa_id', $reabertura->faa_id)->get();

        return $faaReaberta->map(fn ($atendimento) => [
            'tipo' => 'reabertura',
            'id' => $atendimento->id,
            'data_hora' => $atendimento->created_at,
            'profissional' => [
                'id' => $atendimento->createdLotacao->usuario->id,
                'nome' => $atendimento->createdLotacao->usuario->cidadao->nome,
            ],
            'cbo' => $atendimento->createdLotacao->ocupacao->nome,
        ])->all();
    }

    private static function getAtendimentosTriagemData($atendimentosTriagem)
    {
        return $atendimentosTriagem->map(fn ($atendimento) => [
            'tipo' => 'triagem',
            'is_observacao' => false,
            'id' => $atendimento->id,
            'data_hora' => $atendimento->created_at,
            'profissional' => [
                'id' => $atendimento->createdLotacao->usuario->id ?? null,
                'nome' => $atendimento->createdLotacao->usuario->cidadao->nome ?? null,
            ],
            'cbo' => $atendimento->createdLotacao->ocupacao->nome,
            'avaliacao_antropometrica' => self::getAvaliacaoAntropometricaData($atendimento),
            'sinais_vitais' => self::getSinaisVitaisData($atendimento),
            'historico_enfermagem' => $atendimento->historico->descricao ?? null,
            'outras_avaliacoes_condicoes' => $atendimento->outras_avaliacoes_condicoes,
            'observacoes' => $atendimento->observacao->descricao ?? null,
            'procedimentos' => self::getProcedimentosData($atendimento),
        ])->all();
    }

    private static function getAtendimentosMedicosData($atendimentosMedicos)
    {
        return $atendimentosMedicos->map(fn ($atendimento) => [
            'tipo' => 'medico',
            'is_observacao' => $atendimento->is_observacao ?? false,
            'id' => $atendimento->id,
            'data_hora' => $atendimento->created_at,
            'desfecho_id' => $atendimento->desfecho_id,
            'profissional' => [
                'id' => $atendimento->createdLotacao->usuario->id,
                'nome' => $atendimento->createdLotacao->usuario->cidadao->nome,
            ],
            'cbo' => $atendimento->createdLotacao->ocupacao->nome,
            'avaliacao_antropometrica' => self::getAvaliacaoAntropometricaData($atendimento),
            'sinais_vitais' => self::getSinaisVitaisData($atendimento),
            'evolucao' => $atendimento->evolucao,
            'anamnsese' => $atendimento->atendimento_geral,
            'queixa_principal_duracao' => $atendimento->queixa_principal_duracao,
            'historia_paciente' => $atendimento->historia,
            'exame_fisico' => $atendimento->exame_fisico,
            'diagnostico' => $atendimento->diagnostico,
            'conduta' => $atendimento->conduta,
            'observacoes_servicos_enfermagem' => $atendimento->observacoes_enfermagem,
            'observacoes' => $atendimento->observacao->descricao ?? null,
            'servicos_enfermagem' => self::getServicosEnfermagemData($atendimento),
            'exames' => self::getAtendimentoMedicoExamesData($atendimento),
            'prescricoes_internas' => self::getAtendimentoMedicoPrescricoesInternasData($atendimento),
            'procedimentos' => self::getProcedimentosData($atendimento),
            'cid' => $atendimento->cid
                ? MaskUtil::getCidMasked($atendimento->cid->cid->codigo) . " - {$atendimento->cid->cid->nome}"
                : null,
            'reavaliacao' => [
                'solicitou' => $atendimento->solicitou_reavaliacao ? 'SIM' : 'NÃO',
                'data_hora' => $atendimento->solicitou_reavaliacao && $atendimento->data_hora_proxima_reavaliacao
                    ? $atendimento->data_hora_proxima_reavaliacao->format('d/m/Y H:i')
                    : null
            ]
        ])->all();
    }

    private static function getAtendimentoMedicoExamesData($atendimentoMedico)
    {
        $exames = collect();

        $atendimentoMedico->pedidosExames()
            ->orderBy('created_at')
            ->get()
            ->each(fn ($pedido) => $pedido->exames
                ->each(function ($exame) use ($exames) {

                    $procedimento = Procedimento::where('codigo', $exame->exame->codigo)
                        ->orderByDesc('competencia_id')
                        ->firstOrFail();

                    $exames->push([
                        'codigo' => MaskUtil::getProcedimentoMasked($exame->exame->codigo ?? null),
                        'nome' => $procedimento->nome ?? null,
                        'nome_exame' => $exame->exame->nome,
                    ]);
                })
            );

        return $exames->all();
    }

    private static function getAtendimentoMedicoPrescricoesInternasData($atendimentoMedico)
    {
        $medicamentos = collect();

        $atendimentoMedico->prescricoesInternas()
            ->orderBy('created_at')
            ->get()
            ->each(fn ($prescricao) => $prescricao->medicamentos
                ->each(fn ($medicamento) => $medicamentos->push([
                    'medicamento' => $medicamento->medicamento->nome,
                    'frequencia' => $prescricao->frequencia,
                    'quantidade' => $medicamento->quantidade,
                    'unidade_medida_sigla' => $medicamento->unidadeMedida->sigla ?? '',
                    'administracao' => $medicamento->administracao
                ]))
            );

        return $medicamentos->all();
    }

    private static function getAtendimentosEnfermagemData($atendimentosEnfermagem)
    {
        return $atendimentosEnfermagem->map(function ($atendimento) {

            $procedimentos = self::getProcedimentosData($atendimento);

            self::addProfissionalFaturado($procedimentos, $atendimento->created_lotacao_id);

            $atendimento = [
                'tipo' => 'enfermagem',
                'is_observacao' => false,
                'id' => $atendimento->id,
                'data_hora' => $atendimento->created_at,
                'profissional' => [
                    'id' => $atendimento->createdLotacao->usuario->id ?? null,
                    'nome' => $atendimento->createdLotacao->usuario->cidadao->nome ?? null,
                ],
                'cbo' => $atendimento->createdLotacao->ocupacao->nome,
                'avaliacao_antropometrica' => self::getAvaliacaoAntropometricaData($atendimento),
                'sinais_vitais' => self::getSinaisVitaisData($atendimento),
                'historico' => $atendimento->historico->descricao ?? null,
                'diagnostico' => $atendimento->diagnostico->descricao ?? null,
                'planejamento' => $atendimento->planejamento->descricao ?? null,
                'implementacao' => $atendimento->implementacao->descricao ?? null,
                'avaliacao' => $atendimento->avaliacao->descricao ?? null,
                'observacoes' => $atendimento->observacao->descricao ?? null,
                'anotacoes_enfermagem' => self::getAtendimentosEnfermagemObservacaoAnotacoesData($atendimento),
                'exames_laboratoriais' => self::getExamesData($atendimento, ExameTipo::LABORATORIAL),
                'exames_imagem' => self::getExamesData($atendimento, ExameTipo::IMAGEM),
                'laudos' => self::getLaudosExamesData($atendimento),
                'servicos_enfermagem' => self::getServicosEnfermagemData($atendimento),
                'prescricoes_internas' => self::getAtendimentoEnfermagemObservacaoPrescricoesInternasData($atendimento),
                'procedimentos' => $procedimentos,
            ];

            $atendimento['nodata'] = is_null($atendimento['avaliacao_antropometrica'])
                && empty($atendimento['sinais_vitais'])
                && is_null($atendimento['historico'])
                && is_null($atendimento['diagnostico'])
                && is_null($atendimento['planejamento'])
                && is_null($atendimento['implementacao'])
                && is_null($atendimento['avaliacao'])
                && is_null($atendimento['observacoes'])
                && empty($atendimento['anotacoes_enfermagem'])
                && empty($atendimento['exames_laboratoriais'])
                && empty($atendimento['exames_imagem'])
                && empty($atendimento['laudos'])
                && empty($atendimento['servicos_enfermagem'])
                && empty($atendimento['prescricoes_internas'])
                && empty($atendimento['procedimentos']);

            return $atendimento;

        })->all();
    }

    private static function getAtendimentosExameImagemData($atendimentosExameImagem)
    {

        return $atendimentosExameImagem->map(function ($atendimento) {

            $procedimentos = self::getProcedimentosData($atendimento);

            self::addProfissionalFaturado($procedimentos, $atendimento->created_lotacao_id);

            return [
                'tipo' => 'exame_imagem',
                'is_observacao' => $atendimento->is_observacao ?? false,
                'id' => $atendimento->id,
                'data_hora' => $atendimento->created_at,
                'profissional' => [
                    'id' => $atendimento->createdLotacao->usuario->id,
                    'nome' => $atendimento->createdLotacao->usuario->cidadao->nome,
                ],
                'cbo' => $atendimento->createdLotacao->ocupacao->nome,
                'exames_imagem' => self::getExamesData($atendimento, ExameTipo::IMAGEM),
                'laudos' => self::getLaudosExamesData($atendimento),
                'procedimentos' => $procedimentos,
                'observacoes' => $atendimento->observacao->descricao ?? null,
            ];
        })->all();
    }

    private static function addProfissionalFaturado($procedimentos, $atendimentoLotacaoId)
    {

        collect($procedimentos)->each(function ($procedimento) use ($atendimentoLotacaoId) {

            if(!$procedimento){

                if ($procedimento['lotacao_id'] !== $atendimentoLotacaoId) {

                    $lotacao = Lotacao::findOrFail($procedimento['lotacao_id']);

                    $procedimento['nome'] .= " - FATURADO PARA {$lotacao->usuario->cidadao->nome} - "
                    . $lotacao->ocupacao->nome;
                }
            };
        });
    }

    private static function getAtendimentosObservacaoData($atendimentosObservacao)
    {
        return $atendimentosObservacao->map(function ($atendimento) {

            $previousObservacao = $atendimento->atendimento->pacienteObservacoes()
                ->where('id', '<', $atendimento->id)
                ->orderByDesc('id')
                ->first();

            $atendimento = [
                'tipo' => 'observacao',
                'is_observacao' => false,
                'id' => $atendimento->id,
                'data_hora' => $atendimento->created_at,
                'profissional' => [
                    'id' => $atendimento->createdLotacao->usuario->id,
                    'nome' => $atendimento->createdLotacao->usuario->cidadao->nome,
                ],
                'cbo' => $atendimento->createdLotacao->ocupacao->nome,
                'quarto' => $atendimento->quarto,
                'leito' => $atendimento->leito,
                'avaliacao_antropometrica' => self::getAvaliacaoAntropometricaData($atendimento),
                'sinais_vitais' => self::getSinaisVitaisData($atendimento),
                'trauma' => [
                    'hemorragia_externa_grave' => $atendimento->hemorragiaExternaGrave
                        ? $atendimento->hemorragiaExternaGrave->nome . (
                            $atendimento->hemorragia_externa_grave_trauma_status_id === PacienteTraumaStatus::PRESENTE
                                ? " ({$atendimento->hemorragia_externa_grave_local})"
                                : ''
                        )
                        : null,
                    'vias_aereas' => $atendimento->viasAerias
                        ? $atendimento->viasAerias->nome . (
                            $atendimento->vias_aerias_trauma_status_id === PacienteTraumaStatus::OBSTRUCAO
                                ? " ({$atendimento->vias_aerias_obstrucao_por})"
                                : ''
                        )
                        : null,
                    'oxigenacao_respiracao_ventilacao' => $atendimento->oxigenacaoRespiracaoVentilacao->nome ?? null,
                    'circulacao_hemorragias' => [
                        'pulso' => $atendimento->pulso->nome ?? null,
                        'perfusao' => $atendimento->perfuracao
                            ? $atendimento->perfuracao->nome . (
                                $atendimento->perfuracao_trauma_status_id === PacienteTraumaStatus::LENTIFICADA
                                    ? " ({$atendimento->perfuracao_lentificada} segundos)"
                                    : ''
                            )
                            : null,
                        'pele' => $atendimento->pele
                            ? $atendimento->pele->nome . (
                                $atendimento->pele_trauma_status_id === PacienteTraumaStatus::ALTERACOES
                                    ? " ({$atendimento->pele_alteracao})"
                                    : ''
                            )
                            : null,
                        'sangramentos' => $atendimento->sangramento
                            ? $atendimento->sangramento->nome . (
                                $atendimento->sangramento_trauma_status_id === PacienteTraumaStatus::PRESENTE
                                    ? " ({$atendimento->sangramento_local})"
                                    : ''
                            )
                            : null,
                    ],
                    'avaliacao_neurologica' => [
                        'pupilas' => $atendimento->pupilas->nome ?? null,
                        'paresias' => $atendimento->paresias->nome ?? null,
                        'plegia' => $atendimento->plegia->nome ?? null
                    ],
                    'exposicao_hipotermia' => $atendimento->exposicaoHipotermia
                        ? $atendimento->exposicaoHipotermia->nome . (
                            $atendimento->exposicao_hipotermia_trauma_status_id === PacienteTraumaStatus::COM_LESOES
                                ? " ({$atendimento->exposicao_hipotermia_observacao})"
                                : ''
                        )
                        : null,
                ],
                'avaliacao_trauma_parte_corpo' => [
                    'cabeca_pescoco' => $atendimento->avaliacao_cabeca_pescoco,
                    'torax' => $atendimento->avaliacao_torax,
                    'abdome' => $atendimento->avaliacao_abdome,
                    'mmss_mmii' => $atendimento->avaliacao_mmss_mmii,
                ],
                'escalas_glasgow' => self::getAtendimentoObservacaoEscalasGlasgow($atendimento),
                'historico' => $atendimento->historico->descricao ?? null,
                'diagnostico' => $atendimento->diagnostico->descricao ?? null,
                'planejamento' => $atendimento->planejamento->descricao ?? null,
                'implementacao' => $atendimento->implementacao->descricao ?? null,
                'avaliacao' => $atendimento->avaliacao->descricao ?? null,
                'observacoes' => $atendimento->observacao,
                'anotacoes_enfermagem' => self::getAtendimentosEnfermagemObservacaoAnotacoesData($atendimento),
                'exames_laboratoriais' => self::getExamesData($atendimento, ExameTipo::LABORATORIAL),
                'laudos' => self::getLaudosExamesData($atendimento),
                'servicos_enfermagem' => self::getServicosEnfermagemData($atendimento),
                'prescricoes_internas' => self::getAtendimentoEnfermagemObservacaoPrescricoesInternasData(null, $atendimento),
                'procedimentos' => self::getProcedimentosData($atendimento),
            ];

            $atendimento['nodata'] = (is_null($atendimento['quarto'])
                    || is_null($previousObservacao)
                    || $previousObservacao->quarto == $atendimento['quarto']
                )
                && (is_null($atendimento['leito'])
                    || is_null($previousObservacao)
                    || $previousObservacao->leito == $atendimento['leito']
                )
                && is_null($atendimento['avaliacao_antropometrica'])
                && empty($atendimento['sinais_vitais'])
                && is_null($atendimento['trauma']['hemorragia_externa_grave'])
                && is_null($atendimento['trauma']['vias_aereas'])
                && is_null($atendimento['trauma']['oxigenacao_respiracao_ventilacao'])
                && is_null($atendimento['trauma']['circulacao_hemorragias']['pulso'])
                && is_null($atendimento['trauma']['circulacao_hemorragias']['perfusao'])
                && is_null($atendimento['trauma']['circulacao_hemorragias']['pele'])
                && is_null($atendimento['trauma']['circulacao_hemorragias']['sangramentos'])
                && is_null($atendimento['trauma']['avaliacao_neurologica']['pupilas'])
                && is_null($atendimento['trauma']['avaliacao_neurologica']['plegia'])
                && is_null($atendimento['trauma']['exposicao_hipotermia'])
                && is_null($atendimento['avaliacao_trauma_parte_corpo']['cabeca_pescoco'])
                && is_null($atendimento['avaliacao_trauma_parte_corpo']['torax'])
                && is_null($atendimento['avaliacao_trauma_parte_corpo']['abdome'])
                && is_null($atendimento['avaliacao_trauma_parte_corpo']['mmss_mmii'])
                && empty($atendimento['escalas_glasgow']['ocular'])
                && is_null($atendimento['historico'])
                && is_null($atendimento['diagnostico'])
                && is_null($atendimento['planejamento'])
                && is_null($atendimento['implementacao'])
                && is_null($atendimento['avaliacao'])
                && is_null($atendimento['observacoes'])
                && empty($atendimento['anotacoes_enfermagem'])
                && empty($atendimento['exames_laboratoriais'])
                && empty($atendimento['laudos'])
                && empty($atendimento['servicos_enfermagem'])
                && empty($atendimento['prescricoes_internas'])
                && empty($atendimento['procedimentos']);

            return $atendimento;

        })->all();
    }

    private static function getAtendimentoObservacaoEscalasGlasgow($atendimentoObservacao)
    {
        return $atendimentoObservacao->escalasComaGlasgow()->orderBy('created_at')->get()->map(function ($escala) {

            $pontuacao = $escala->aberturaOcular->pontos
                + $escala->respostaVerbal->pontos
                + $escala->respostaMotora->pontos
                - $escala->reatividadePupilar->pontos;

            if ($escala->aberturaOcular->pontos === 0
                || $escala->respostaVerbal->pontos === 0
                || $escala->respostaMotora->pontos === 0
            ) {

                $resultado = 'A pontuação não pode ser calculada. Um ou mais itens não foram testados.';
            }
            else {

                $resultado = (GlasgowInterpretacaoResultado::all()->filter(function ($interpretacao) use ($pontuacao) {

                    return $pontuacao >= $interpretacao->min
                        && $pontuacao <= ($interpretacao->max ?? PHP_INT_MAX);
                })->first())->descricao;
            }

            return [
                'ocular' => $escala->aberturaOcular->pontos,
                'verbal' => $escala->respostaVerbal->pontos,
                'motora' => $escala->respostaMotora->pontos,
                'pupilar' => $escala->reatividadePupilar->pontos,
                'pontuacao' => $pontuacao,
                'resultado' => $resultado
            ];
        })->all();
    }

    private static function getAtendimentosEnfermagemObservacaoAnotacoesData($atendimento)
    {
        return $atendimento->anotacoes()->orderBy('created_at')->get()->map(fn ($anotacao) => [
            'data_hora' => $anotacao->anotado_em->format('d/m/Y H:i'),
            'descricao' => $anotacao->descricao
        ])->all();
    }

    private static function getAtendimentoEnfermagemObservacaoPrescricoesInternasData(
        $atendimentoEnfermagem = null,
        $atendimentoObservacao = null
    ) {
        $medicamentos = collect();

        PrescricaoInterna::whereHas('medicamentos',
            function ($query) use ($atendimentoEnfermagem, $atendimentoObservacao) {

                $query->whereHas('aplicacoes', function ($query) use ($atendimentoEnfermagem, $atendimentoObservacao) {

                    $query
                        ->when($atendimentoEnfermagem, function ($query, $atendimentoEnfermagem) {

                            $query->where('atendimento_enfermagem_id', $atendimentoEnfermagem->id);
                        })
                        ->when($atendimentoObservacao, function ($query, $atendimentoObservacao) {

                            $query->where('paciente_observacao_id', $atendimentoObservacao->id);
                        });
                });
            }
        )
            ->orderBy('created_at')
            ->get()
            ->each(fn ($prescricao) => $prescricao->medicamentos()
                ->whereHas('aplicacoes', function ($query) use ($atendimentoEnfermagem, $atendimentoObservacao) {

                    $query
                        ->when($atendimentoEnfermagem, function ($query, $atendimentoEnfermagem) {

                            $query->where('atendimento_enfermagem_id', $atendimentoEnfermagem->id);
                        })
                        ->when($atendimentoObservacao, function ($query, $atendimentoObservacao) {

                            $query->where('paciente_observacao_id', $atendimentoObservacao->id);
                        });
                })
                ->get()
                ->each(fn ($medicamento) => $medicamentos->push([
                    'medicamento' => $medicamento->medicamento->nome,
                    'frequencia' => $prescricao->frequencia,
                    'quantidade' => $medicamento->quantidade,
                    'unidade_medida_sigla' => $medicamento->unidadeMedida->sigla ?? '',
                    'administracao' => $medicamento->administracao,
                    'aplicacoes' => ($atendimentoEnfermagem->automatico ?? false)
                        ? []
                        : $medicamento->aplicacoes->map(fn ($aplicacao, $i) => [
                            'numero' => $i + 1,
                            'status' => $aplicacao->status->nome . ($aplicacao->status->id === Status::REALIZADO
                                ? ' às ' . (new Carbon($aplicacao->horario_aplicacao))->format('H:i') . ' h'
                                : ''
                            )
                        ])->all()
                ]))
            );

        return $medicamentos->all();
    }

    private static function getAvaliacaoAntropometricaData($atendimento)
    {
        $avaliacao = $atendimento->avaliacaoAntropometrica;

        if (is_null($avaliacao)) {

            return null;
        }

        return [
            'peso' => $avaliacao->massa
                ? str_replace('.', ',', "{$avaliacao->massa} {$avaliacao->massaUnidadeMedida->sigla}")
                : null,
            'altura' => $avaliacao->altura
                ? str_replace('.', ',', "{$avaliacao->altura} {$avaliacao->alturaUnidadeMedida->sigla}")
                : null
        ];
    }

    private static function getSinaisVitaisData($atendimento)
    {
        $getSigla = fn ($id) => UnidadeMedida::findOrFail($id)->sigla;

        return $atendimento->sinaisVitais()->orderBy('created_at')->get()->map(fn ($sinal) => [
            'pa' => $sinal->pa
                ? "{$sinal->pa} {$sinal->paUnidadeMedida->sigla}"
                : null,
            'glicemia' => $sinal->glicemia
                ? "{$sinal->glicemia} " . $getSigla(CadastroUnidadeMedida::MILIGRAMAS_POR_DECILITRO)
                : null,
            'temperatura' => $sinal->temperatura
                ? str_replace('.', ',', "{$sinal->temperatura} " . $getSigla(CadastroUnidadeMedida::CELSIUS))
                : null,
            'pulso' => $sinal->pulso
                ? "{$sinal->pulso} " . $getSigla(CadastroUnidadeMedida::BATIMENTOS_POR_MINUTO)
                : null,
            'respiracao' => $sinal->respiracao
                ? "{$sinal->respiracao} " . $getSigla(CadastroUnidadeMedida::MOVIMENTOS_POR_MINUTO)
                : null,
            'saturacao' => $sinal->saturacao
                ? "{$sinal->saturacao} " . $getSigla(CadastroUnidadeMedida::PORCENTAGEM)
                : null,
            'intensidade_dor' => $sinal->intensidade_dor,
            'cintura' => $sinal->cintura
                ? "{$sinal->cintura} " . $getSigla(CadastroUnidadeMedida::CENTIMETROS)
                : null,
        ])->all();
    }

    private static function getProcedimentosData($atendimento)
    {
        return $atendimento->procedimentos()->orderBy('created_at')->get()->map(fn ($procedimento) => collect([
            'codigo' => MaskUtil::getProcedimentoMasked($procedimento->procedimento->codigo ?? null),
            'nome' => $procedimento->procedimento->nome ?? null,
            'lotacao_id' => $procedimento->lotacao_id ?? null,
        ]))->all();
    }

    private static function getServicosEnfermagemData($atendimento)
    {
        return $atendimento->servicosEnfermagem()->orderBy('created_at')->get()->map(fn ($servico) => [
            'codigo' => MaskUtil::getProcedimentoMasked($servico->procedimento->codigo ?? null),
            'nome' => $servico->procedimento->nome ?? null,
            'observacoes' => $servico->observacoes,
            'status' => $servico->status->nome . ($servico->status->id === Status::REALIZADO
                ? ' às ' . (new Carbon($servico->horario_realizacao))->format('H:i') . ' h'
                : ''
            )
        ])->all();
    }

    private static function getExamesData($atendimento, $tipoId)
    {

        return $atendimento->pedidoExameItems()
            ->whereHas('exame', fn ($q) => $q->where('tipo_id', $tipoId))
            ->orderBy('created_at')
            ->get()
            ->map(function ($exame) {

                $procedimento = Procedimento::where('codigo', $exame->exame->codigo)
                    ->orderByDesc('competencia_id')
                    ->firstOrFail();

                return [
                    'codigo' => MaskUtil::getProcedimentoMasked($exame->exame->codigo ?? null),
                    'nome' => $procedimento->nome ?? null,
                    'nome_exame' => $exame->exame->nome ?? null,
                    'status' => $exame->status->nome
                        . ($exame->status->id === Status::REALIZADO && $exame->horario_realizacao
                            ? ' às ' . (new Carbon($exame->horario_realizacao))->format('H:i') . ' h'
                            : '')
                ];
            })
            ->all();
    }

    private static function getLaudosExamesData($atendimento)
    {
        return $atendimento->pedidoExameLaudos()
            ->orderBy('created_at')
            ->get()
            ->map(fn ($laudo) => ['nome' => $laudo->nome])
            ->all();
    }

    private static function getPacienteData($atendimento)
    {
        $paciente = $atendimento->faa->paciente;
        $cidadao = $paciente->cidadao;
        $gestacao = $atendimento->gestacoes->sortByDesc('created_at')->first();

        return [
            'nome' => $cidadao->nome,
            'nome_social' => $cidadao->nome_social,
            'prefereNome' => $cidadao->preferencia_nome_id ?? null,
            'prontuario' => $paciente->prontuario,
            'cns' => $cidadao->cns ? MaskUtil::getCnsMasked($cidadao->cns) : 'NÃO INFORMADO',
            'cpf' => $cidadao->cpf ? MaskUtil::getCpfMasked($cidadao->cpf) : 'NÃO INFORMADO',
            'sexo' => $cidadao->sexo->descricao,
            'data_nascimento' => $cidadao->data_nascimento
                ? $cidadao->data_nascimento->format('d/m/Y')
                : 'NÃO INFORMADA',
            'idade' => $cidadao->data_nascimento
                ? "{$cidadao->idade['anos']} ano(s), "
                    . "{$cidadao->idade['meses']} mês(es) e "
                    . "{$cidadao->idade['dias']} dia(s) "
                : 'NÃO INFORMADA',
            'idade_gestacional' => $gestacao && $gestacao->idade_gestacional
                ? "{$gestacao->idade_gestacional['semanas']} semana(s) e {$gestacao->idade_gestacional['dias']} dia(s)"
                : null,
            'nome_mae' => $cidadao->nome_mae ?? 'NÃO INFORMADO',
            'endereco' => $cidadao->domicilio
                ? "{$cidadao->domicilio->endereco->completo}, "
                    . MaskUtil::getCepMasked($cidadao->domicilio->endereco->logradouro->cep)
                : 'NÃO INFORMADO',
            'telefones' => $cidadao->telefones->map(fn ($t) => MaskUtil::getPhoneMasked($t->numero))->all(),
        ];
    }

    private static function getRaatData($atendimento)
    {
        $raat = $atendimento->faa->raat;

        if (!$raat) {

            return null;
        }

        $titulo = '';

        switch ($raat->tipo_formulario_acidente_trabalho) {
            case TipoFormularioAcidenteTrabalho::RAAT:
                $titulo = 'Raat Aberta';
                break;
            case TipoFormularioAcidenteTrabalho::CAT:
                $titulo = 'Cat Aberta';
                break;
            default:
                $titulo = 'Cat/Raat Aberta';
        }

        $formularioTemCat = $raat->tipo_formulario_acidente_trabalho != TipoFormularioAcidenteTrabalho::RAAT;

        $cat = Cat::where('raat_id', $raat->id)->first();

        $parecerMedico = $raat->pareceresMedico()->orderByDesc('created_at')->first();

        if ($parecerMedico) {

            $parecerMedico = [
                'agente' => $parecerMedico->agente->nome,
                'causas_acidente' => $parecerMedico->causasAcidente->map(
                    function ($causa) use ($parecerMedico) {

                        if ($causa->id === CausaAcidente::OUTROS) {

                            $causa->nome .= is_null($parecerMedico->causa_acidente_outras)
                                ? " (NÃO INFORMADA)"
                                : " ({$parecerMedico->causa_acidente_outras})";
                        }

                        return $causa->nome;
                    }
                )->all(),
                'partes_corpo_atingidas' => $parecerMedico->partesCorpoAtingidas->map(
                    function ($parte) use ($parecerMedico) {

                        if ($parte->id === ParteCorpoAtingida::OUTROS) {

                            $parte->nome .= is_null($parecerMedico->parte_corpo_atingida_outras)
                                ? " (NÃO INFORMADO)"
                                : " ({$parecerMedico->parte_corpo_atingida_outras})";
                        }

                        return $parte->nome;
                    }
                )->all(),
                'diagnosticos' => $parecerMedico->diagnosticos->map(
                    function ($diagnostico) use ($parecerMedico) {

                        if ($diagnostico->id === DiagnosticoRaat::OUTROS) {

                            $diagnostico->nome .= is_null($parecerMedico->diagnostico_outros)
                                ? " (NÃO INFORMADO)"
                                : " ({$parecerMedico->diagnostico_outros})";
                        }

                        return $diagnostico->nome;
                    }
                )->all(),
                'cid' => ($parecerMedico->atendimentoMedico->cid->cid ?? null)
                    ? $parecerMedico->atendimentoMedico->cid->cid->codigo
                        . ' - ' . $parecerMedico->atendimentoMedico->cid->cid->nome
                    : '',
                'observacao' => $parecerMedico->observacao ?? null,
                'classificacao_inicial' => $parecerMedico->classificacaoInicial->nome,
                'com_afastamento' => $parecerMedico->afastado ? 'SIM' : 'NÃO',
                'sofreu_acidente_trabalho' => $cat && $formularioTemCat ?  ($cat->paciente_sofreu_acidente_trabalho ? 'SIM' : 'NÃO') : null,
                'portador_doenca_ocupacional' => $cat && $formularioTemCat ? ($cat->paciente_portador_doenca_ocupacional ? 'SIM' : 'NÃO') : null,
                'precisa_internacao' => $cat && $formularioTemCat ? ($cat->paciente_precisa_internacao ? 'SIM' : 'NÃO') : null,
                'dias_afastamento' => $cat && $formularioTemCat ? ($cat->dias_afastamento ?? 'NÃO INFORMADO') : null,
            ];
        }

        return [
            'titulo_formulario'=> $titulo,
            'empresa' => [
                'nome' => $raat->empresa_nome,
                'ramo_atividade' => $raat->empresa_ramo_atividade,
                'telefone' => $raat->empresa_telefone
                    ? MaskUtil::getPhoneMasked($raat->empresa_telefone)
                    : null,
                'endereco' => $raat->empresa_endereco,
                'ocupacao_paciente' => $cat && $formularioTemCat ? $cat->empresa_ocupacao_paciente : null
            ],
            'acidente' => [
                'data' => $raat->acidente_data->format('d/m/Y'),
                'hora' => $raat->acidente_hora ? $raat->acidente_hora->format('H:i') : null,
                'tipo' => $raat->tipoAcidente->nome ?? null,
                'regime_trabalho' => $raat->regimeTrabalho->nome ?? null,
                'regime_trabalho_outro' => $raat->regimeTrabalho
                    ? ($raat->regime_trabalho_outro ?? 'NÃO INFORMADO')
                    : '',
                'local' => $raat->acidente_local,
                'descricao' => $raat->acidente_descricao,
            ],
            'parecer_medico' => $parecerMedico
        ];
    }

    private static function getClassificacoesRiscoData($atendimento)
    {
        $classificacoes = collect();
        $previousClassificacaoId = null;

        $atendimento->classificacoesRisco()
            ->orderBy('created_at')
            ->get()
            ->each(function ($classificacao) use (&$previousClassificacaoId, $classificacoes) {

                if ($classificacao->classificacao_risco_id !== $previousClassificacaoId) {

                    $classificacoes->push([
                        'data_hora' => $classificacao->created_at->format('d/m/Y H:i:s'),
                        'nome' => $classificacao->classificacaoRisco->nome,
                        'profissional' => $classificacao->createdLotacao->usuario->cidadao->nome ?? null,
                        'cbo' => $classificacao->createdLotacao->ocupacao->nome,
                        'setor' => $classificacao->createdCentroCusto->setor->nome,
                    ]);
                }

                $previousClassificacaoId = $classificacao->classificacao_risco_id;
            });

        return $classificacoes->all();
    }

    private static function getFatoresRiscoData($atendimento, $until)
    {
        if (is_null($until)) {

            return [];
        }

        return $atendimento->faa->paciente->cidadao->fatoresRisco()
            ->wherePivot('created_at', '<=', $until)
            ->get()
            ->map(fn ($fatorRisco) => [
                'data_hora' => $fatorRisco->cidadaoFatorRisco->created_at->format('d/m/Y H:i:s'),
                'nome' => $fatorRisco->id == EnumFatorRisco::OUTRO
                    ? $fatorRisco->nome .' (' . $atendimento->faa->paciente->cidadao->fator_risco_outro . ')'
                    : $fatorRisco->nome,
                'profissional' => $fatorRisco->cidadaoFatorRisco->createdLotacao()->withTrashed()->first()->usuario->cidadao->nome,
                'cbo' => $fatorRisco->cidadaoFatorRisco->createdLotacao()->withTrashed()->first()->ocupacao->nome,
                'setor' => $fatorRisco->cidadaoFatorRisco->createdCentroCusto->setor->nome,
            ])
            ->sortBy('data_hora')
            ->values()
            ->all();
    }

    private static function getAlergiasData($atendimento, $until)
    {
        if (is_null($until)) {

            return [];
        }

        return $atendimento->faa->paciente->cidadao->alergias()
            ->wherePivot('created_at', '<=', $until)
            ->get()
            ->map(fn ($alergia) => [
                'data_hora' => $alergia->cidadaoAlergia->created_at->format('d/m/Y H:i:s'),
                'nome' => $alergia->agente_substancia_especifica,
                'profissional' => $alergia->cidadaoAlergia->createdLotacao->usuario->cidadao->nome ?? null,
                'cbo' => $alergia->cidadaoAlergia->createdLotacao->ocupacao->nome,
                'setor' => $alergia->cidadaoAlergia->createdCentroCusto->setor->nome,
            ])
            ->sortBy('data_hora')
            ->values()
            ->all();
    }

    private static function getMedicamentosUsoContinuoData($atendimento, $until)
    {

        if (is_null($until)) {

            return [];
        }

        return $atendimento->faa->paciente->cidadao->medicamentosUsoContinuo()
            ->wherePivot('created_at', '<=', $until)
            ->get()
            ->map(fn ($medicamento) => [
                'data_hora' => $medicamento->CidadaoMedicamentoUsoContinuo->created_at->format('d/m/Y H:i:s'),
                'nome' => $medicamento->nome,
                'profissional' => $medicamento->CidadaoMedicamentoUsoContinuo->createdLotacao->usuario->cidadao->nome,
                'cbo' => $medicamento->CidadaoMedicamentoUsoContinuo->createdLotacao->ocupacao->nome,
                'setor' => $medicamento->CidadaoMedicamentoUsoContinuo->createdCentroCusto->setor->nome,
            ])
            ->sortBy('data_hora')
            ->values()
            ->all();
    }

    private static function getMedicamentosEmUsoData($atendimento)
    {
        return $atendimento->medicamentosUso()->orderBy('created_at')->get()->map(fn ($medicamento) => [
            'data_hora' => $medicamento->created_at->format('d/m/Y H:i:s'),
            'descricao' => $medicamento->descricao,
            'profissional' => $medicamento->createdLotacao->usuario->cidadao->nome,
            'cbo' => $medicamento->createdLotacao->ocupacao->nome,
            'setor' => $medicamento->createdCentroCusto->setor->nome,
        ])->all();
    }

    private static function getProcedimentosFechamentoData($atendimento)
    {
        $atendimentosProcedimentos = collect();

        $atendimento->procedimentos()
            ->whereNull('atendimento_medico_id')
            ->whereNull('atendimento_triagem_id')
            ->whereNull('atendimento_enfermagem_id')
            ->whereNull('paciente_observacao_id')
            ->whereNull('exame_imagem_id')
            ->get()
            ->each(function ($atendimentoProcedimento) use ($atendimentosProcedimentos) {

                $realizadoEm = Carbon::create(
                    $atendimentoProcedimento->realizado_em->year,
                    $atendimentoProcedimento->realizado_em->month,
                    $atendimentoProcedimento->realizado_em->day,
                    23,
                    59,
                    59
                );

                $realizadoEmFormatted = $realizadoEm->format('d/m/Y H:i:s');

                $atendimentoProcedimentoProfissional = $atendimentosProcedimentos
                    ->where('lotacao_id', $atendimentoProcedimento->lotacao_id)
                    ->where('data_hora_formatted', $realizadoEmFormatted)
                    ->first();

                if (is_null($atendimentoProcedimentoProfissional)) {

                    $atendimentoProcedimentoProfissional = collect([
                        'tipo' => 'fechamento',
                        'is_observacao' => false,
                        'id' => null,
                        'lotacao_id' => $atendimentoProcedimento->lotacao_id,
                        'profissional' => [
                            'id' => $atendimentoProcedimento->lotacao->usuario->id,
                            'nome' => $atendimentoProcedimento->lotacao->usuario->cidadao->nome,
                        ],
                        'cbo' => $atendimentoProcedimento->lotacao->ocupacao->nome,
                        'data_hora_formatted' => $realizadoEmFormatted,
                        'data_hora' => $realizadoEm,
                        'cid' => null,
                        'procedimentos' => collect(),
                    ]);

                    $atendimentosProcedimentos->push($atendimentoProcedimentoProfissional);
                }

                if ($atendimentoProcedimento->is_parametrizado) {

                    if ($atendimentoProcedimento->cidPrincipalId) {

                        $cid = Cid::find($atendimentoProcedimento->cidPrincipalId, ['codigo', 'nome']);

                        $atendimentoProcedimentoProfissional['cid'] = MaskUtil::getCidMasked(
                            $cid->codigo)
                        . " - {$cid->nome}";
                    }
                }

                $procedimento = Procedimento::find($atendimentoProcedimento->procedimento_id, ['codigo', 'nome']);

                if($procedimento){

                    $atendimentoProcedimentoProfissional['procedimentos']->push(collect([
                    'codigo' => MaskUtil::getProcedimentoMasked($procedimento->codigo ?? null),
                    'nome' => $procedimento->nome ?? null
                    ]));
                }
            });

        return $atendimentosProcedimentos->all();
    }

    private static function getDesfechoData($atendimento)
    {
        $faa = $atendimento->faa;

        if (is_null($faa->desfecho_id)) {

            return null;
        }

        $evasao = null;
        $encaminhamentoHospitalar = null;
        $obito = null;

        if ($faa->desfecho->id === Desfecho::EVASAO) {

            $evasao = [
                'motivo' => $atendimento->fila->motivo_evasao ?? null
            ];
        }
        else if ($faa->desfecho->id === Desfecho::ENCAMINHAMENTO_HOSPITALAR) {

            $lastEncaminhamento = $atendimento->encaminhamentosHospitalar()->orderByDesc('created_at')->first();

            $encaminhamentoHospitalar = [
                'unidade_encaminhamento' => $lastEncaminhamento->unidade->nome_fantasia
                    ?? $lastEncaminhamento->unidade_nome,
                'quarto' => $lastEncaminhamento->quarto ?? 'NÃO INFORMADO',
                'leito' => $lastEncaminhamento->leito ?? 'NÃO INFORMADO',
                'medico_hospitalar' => $lastEncaminhamento->medico_hospitalar ?? 'NÃO INFORMADO',
                'cid' => isset($lastEncaminhamento->cid)
                    ? "{$lastEncaminhamento->cid->codigo} - {$lastEncaminhamento->cid->nome}"
                    : null,
                'observacoes' => $lastEncaminhamento->observacoes ?? 'NÃO INFORMADO'
            ];
        }
        else if ($faa->desfecho->id === Desfecho::OBITO) {

            $obito = [
                'data' => (new Carbon($faa->paciente->cidadao->obito->obito_em))->format('d/m/Y'),
                'hora' => (new Carbon($faa->paciente->cidadao->obito->obito_em))->format('H:i'),
                'numero_declaracao' => $faa->paciente->cidadao->obito->declaracao,
                'cid' => isset($faa->paciente->cidadao->obito->cid)
                    ? "{$faa->paciente->cidadao->obito->cid->codigo} - {$faa->paciente->cidadao->obito->cid->nome}"
                    : null,
                'causa' => $faa->paciente->cidadao->obito->causa
            ];
        }

        return [
            'data_hora' => $faa->data_hora_desfecho
                ? (new Carbon($faa->data_hora_desfecho))->format('d/m/Y H:i:s')
                : '',
            'profissional' => $faa->usuario->cidadao->nome ?? '',
            'cbo' => $faa->lotacao->ocupacao->nome ?? '',
            'nome' => $atendimento->faa->desfecho->nome,
            'evasao' => $evasao,
            'encaminhamento_hospitalar' =>$encaminhamentoHospitalar,
            'obito' => $obito

        ];
    }
}