rkm-conectasus-ci-sandbox/api/app/Http/Controllers/ProntoAtendimento/Atendimento/Medico/AtendimentoMedicoController.php

<?php

namespace App\Http\Controllers\ProntoAtendimento\Atendimento\Medico;

use App\Enums\Cadastro\Estabelecimento\SetorTipo;
use App\Enums\Cadastro\Medicamento\TipoPosologia;
use App\Enums\Cadastro\Medicamento\ViaAdministracao as EnumViaAdministracao;
use App\Enums\Cadastro\SujeitoAtencao\Deficiencia;
use App\Enums\Cadastro\SujeitoAtencao\FatorRisco as FatorRiscoEnum;
use App\Enums\Cadastro\SujeitoAtencao\Sexo;
use App\Enums\Cadastro\UnidadeMedida as UnidadeMedidaEnum;
use App\Enums\Geral\TipoMedidaAltura as TipoMedidaAlturaEnum;
use App\Enums\Parametrizacao\Exame\Status as ExameStatusEnum;
use App\Enums\Parametrizacao\KitExame\Tipo;
use App\Enums\Parametrizacao\ProntoAtendimento\TipoAtendimento;
use App\Enums\ProntoAtendimento\Atendimento\Desfecho;
use App\Enums\ProntoAtendimento\Atendimento\Medico\AtestadoModelo;
use App\Enums\ProntoAtendimento\Atendimento\DorToracica as DorToracicaEnum;
use App\Enums\ProntoAtendimento\Atendimento\Medico\DeclaracaoComparecimentoTipo;
use App\Enums\ProntoAtendimento\Raat\CausaAcidente;
use App\Enums\ProntoAtendimento\Raat\Diagnostico;
use App\Enums\ProntoAtendimento\Raat\ParteCorpoAtingida;
use App\Enums\ProntoAtendimento\TipoFormularioAcidenteTrabalho;
use App\Enums\Sigtap\Procedimento as ProcedimentoEnum;
use App\Enums\AtencaoBasica\CadastroIndividual\SaidaCidadao;
use App\Http\Controllers\Controller;
use App\Http\Requests\ProntoAtendimento\Atendimento\MedicoRequest;
use App\Models\Cadastro\Estabelecimento\CentroCusto;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\Medicamento\FormaFarmaceutica;
use App\Models\Cadastro\Medicamento\Medicamento;
use App\Models\Cadastro\Medicamento\ReceitaTipo;
use App\Models\Cadastro\Medicamento\ViaAdministracao;
use App\Models\Cadastro\SujeitoAtencao\AlergiaCriticidade;
use App\Models\Cadastro\SujeitoAtencao\AlergiaTipo;
use App\Models\Cadastro\SujeitoAtencao\FatorRisco;
use App\Models\Cadastro\SujeitoAtencao\Lotacao;
use App\Models\Cadastro\SujeitoAtencao\PacienteHistorico;
use App\Models\AtencaoBasica\CadastroIndividual\CadastroIndividual;
use App\Models\Cadastro\SujeitoAtencao\PacienteInformacaoSocial;
use App\Models\Cadastro\UnidadeMedida;
use App\Models\Cns\TermoInvalido;
use App\Models\Geral\DocumentoTipo;
use App\Models\Geral\GlasgowAberturaOcular;
use App\Models\Geral\GlasgowInterpretacaoResultado;
use App\Models\Geral\GlasgowReatividadePupilar;
use App\Models\Geral\GlasgowRespostaMotora;
use App\Models\Geral\GlasgowRespostaVerbal;
use App\Models\Geral\MedidaTempo;
use App\Models\Geral\Turno;
use App\Models\PainelSenha\Encaminhamento;
use App\Models\PainelSenha\Fila;
use App\Models\PainelSenha\Prioridade;
use App\Models\Parametrizacao\Exame\Exame;
use App\Models\Parametrizacao\KitExame\KitExame;
use App\Models\ProntoAtendimento\Atendimento\Atendimento;
use App\Models\ProntoAtendimento\Atendimento\Cat;
use App\Models\ProntoAtendimento\Atendimento\Desfecho as ModelDesfecho;
use App\Models\ProntoAtendimento\Atendimento\EncaminhamentoEspecialidade;
use App\Models\ProntoAtendimento\Atendimento\Enfermagem\Anotacao;
use App\Models\ProntoAtendimento\Atendimento\Enfermagem\AtendimentoEnfermagem;
use App\Models\ProntoAtendimento\Atendimento\Enfermagem\Avaliacao;
use App\Models\ProntoAtendimento\Atendimento\Enfermagem\Diagnostico as DiagnosticoEnfermagem;
use App\Models\ProntoAtendimento\Atendimento\Enfermagem\Historico;
use App\Models\ProntoAtendimento\Atendimento\Enfermagem\Implementacao;
use App\Models\ProntoAtendimento\Atendimento\Enfermagem\Planejamento;
use App\Models\ProntoAtendimento\Atendimento\EscalaComaGlasgow;
use App\Models\ProntoAtendimento\Atendimento\ExameImagem\AtendimentoExameImagem;
use App\Models\ProntoAtendimento\Atendimento\Medico\AtendimentoMedico;
use App\Models\ProntoAtendimento\Atendimento\Medico\Receita;
use App\Models\ProntoAtendimento\Atendimento\Observacao\PacienteObservacao;
use App\Models\ProntoAtendimento\Atendimento\PacienteTraumaStatus;
use App\Models\ProntoAtendimento\Atendimento\Raat;
use App\Models\ProntoAtendimento\Atendimento\Recepcao;
use App\Models\ProntoAtendimento\Atendimento\ServicoEnfermagem;
use App\Models\ProntoAtendimento\Atendimento\Triagem\AtendimentoTriagem;
use App\Models\ProntoAtendimento\Atendimento\Triagem\DorToracicaSinalInstabilidade;
use App\Models\ProntoAtendimento\Atendimento\Triagem\FormularioDorToracica;
use App\Models\ProntoAtendimento\Atendimento\Triagem\FormularioDorToracicaResultadoEletrocardiograma;
use App\Models\ProntoAtendimento\Atendimento\Triagem\OrigemDorToracica;
use App\Models\ProntoAtendimento\Atendimento\Triagem\RelacionadoFormularioDorToracica;
use App\Models\ProntoAtendimento\ClassificacaoRisco\ClassificacaoRisco;
use App\Models\ProntoAtendimento\Parametrizacao\AtendimentoMedico as ParametrizacaoAtendimentoMedico;
use App\Models\ProntoAtendimento\Parametrizacao\Parametrizacao;
use App\Models\Sigtap\Ocupacao;
use App\Models\Sigtap\Procedimento;
use App\Services\Ambulatorio\AtendimentoService as AmbulatorioAtendimentoService;
use App\Services\Cadastro\SujeitoAtencao\ObitoService;
use App\Services\Parametrizacao\ProntoAtendimento\AtendimentoMedicoService as ParametrizacaoAtendimentoMedicoService;
use App\Services\ProntoAtendimento\AcidenteTrabalhoService;
use App\Services\ProntoAtendimento\Atendimento\AtendimentoService;
use App\Services\ProntoAtendimento\Atendimento\RaatService;
use App\Services\ProntoAtendimento\Fila\FilaService;
use App\Services\ProntoAtendimento\Impressao\ImpressaoService;
use App\Services\ProntoAtendimento\PlantaoService;
use App\Services\ProntoAtendimento\ProcedimentoObservacaoService;
use App\Services\Sigtap\ProcedimentoValidationService;
use Carbon\Carbon;
use Exception;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;

class AtendimentoMedicoController extends Controller
{
    protected $modulo = 'pronto-atendimento';
    protected $funcionalidade = 'atendimento-medico';

    public function index()
    {
        $plantao = PlantaoService::getCurrentPlantao();

        return response()->json(
            [
                'additionals' => [
                    'plantao_id' => $plantao->id ?? null,
                    'plantao_faixa_etaria_id' => $plantao->faixa_etaria_id ?? null,
                ],
            ],
            Response::HTTP_OK
        );
    }

    public function storeFaaAssinada($id)
    {
        $path = 'assinatura-eletronica' . DIRECTORY_SEPARATOR . app('config')->get('database.default') . DIRECTORY_SEPARATOR . 'pronto-atendimento' . DIRECTORY_SEPARATOR . 'atendimento-medico';
        $arquivo = "{$id}.PDF";

        $atendimentoMedico = AtendimentoMedico::findOrFail($id);

        if (!is_null($atendimentoMedico)) {
            $pdf = base64_decode(request()->faa_assinada['data']);

            if (!Storage::disk('local')->put($path . DIRECTORY_SEPARATOR . $arquivo, $pdf)) {
                throw new Exception('Erro ao assinar o arquivo.');
            } else {
                $atendimentoMedico->update(['is_faa_assinada' => true]);
            }
        }

        return response($atendimentoMedico->fresh(), Response::HTTP_OK);
    }

    public function storeReceitasAssinadas($id)
    {
        $path = 'assinatura-eletronica' . DIRECTORY_SEPARATOR . app('config')->get('database.default') . DIRECTORY_SEPARATOR . 'pronto-atendimento' . DIRECTORY_SEPARATOR . 'atendimento-medico-receita-medica';

        $receita = Receita::findOrFail($id);
        $proximaOrdem = $receita->receitasAssinadas()->max('ordem') + 1;

        foreach (request()->receitas_assinadas as $receitaAssinada) {
            $pdf = base64_decode($receitaAssinada);

            $idReceitaAssinada = $receita->receitasAssinadas()->create(['ordem' => $proximaOrdem])->id;

            $arquivo = "{$idReceitaAssinada}.PDF";

            if (!Storage::disk('local')->put($path . DIRECTORY_SEPARATOR . $arquivo, $pdf)) {
                throw new Exception('Erro ao assinar o arquivo.');
            }
        }

        $receita->update(['is_assinada' => true]);

        return response($receita->fresh(), Response::HTTP_OK);
    }

    public function create($id)
    {
        $this->auth(__FUNCTION__);

        $centroCustoLogado = $this->getCentroCustoLogado();
        $lotacao = $this->getLotacaoLogado();

        $model = [
            'profissional' => $lotacao->usuario->cidadao->nome,
            'ocupacao' => $lotacao->ocupacao,
        ];

        if ($id) {

            $atendimento = Atendimento::where('fila_id', $id)
                ->orderBy('created_at', 'desc')
                ->firstOrFail();

            $atendimento->faa->makeHidden('paciente');
            $ultimaClassificacaoRisco = $atendimento->classificacoesRisco()->orderByDesc('created_at')->first();
            $faa = $atendimento->faa;
            $alergias = $this->getAlergias($atendimento, Carbon::now());
            $medicamentosUsoContinuo = $this->getMedicamentosUsoContinuo($atendimento, Carbon::now());

            $cids = $atendimento->cids()
                ->with('cid')
                ->orderBy('created_at')
                ->get()
                ->makeHidden(['atendimento_id', 'atendimento_medico_id', 'cid_id']);
            $cidPrincipal = $cids->last();

            $atendimentoMedico = $atendimento->atendimentosMedico()->orderByDesc('created_at')->first();
            $parecerMedico = $faa->raat && $faa->raat->pareceresMedico ? $faa->raat->pareceresMedico()->orderByDesc('created_at')->first() : [];

            if($faa->paciente->cidadao->sexo_id === Sexo::FEMININO && $faa->paciente->cidadao->idade
                && $faa->paciente->cidadao->idade['anos'] >= 9 && $faa->paciente->cidadao->idade['anos'] <= 60){

                    $exibirFatorRiscoGestante = true;

            } else {

                $exibirFatorRiscoGestante = false;
            }

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

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

                foreach ($formulario as $registro) {

                    $formulario_id = $registro->id;
                    $data_sintoma = $registro->data_sintoma;
                    $hora_sintoma = $registro->hora_sintoma;
                    $data_ecg_admissao = $registro->data_ecg_admissao;
                    $hora_ecg_admissao = $registro->hora_ecg_admissao;
                    $dispneia = $registro->dispneia;
                    $dorToracicaProtocoloFinalizado = $registro->protocolo_finalizado;
                    $dorToracicaProtocoloTemProsseguimento = $registro->protocolo_tem_prosseguimento;
                    $dorToracicaTemContraIndicacaoTrombolitico = $registro->tem_contra_indicacao_trombolitico;
                    $dorToracicaContraIndicacaoTromboliticoMotivo = $registro->contra_indicacao_trombolitico_motivo;
                }

                $formularioRelacionadoDor = RelacionadoFormularioDorToracica::where('formulario_id', $formulario_id)->get();

                $dorToracicaRelacionada = [];

                foreach ($formularioRelacionadoDor as $registroRelacionado) {

                    $dorToracicaRelacionada[] = $registroRelacionado->dor_toracica_id;
                }

                $formularioDorToracica = $formulario->where('id', $formulario_id)->first();

                $dorToracicaGetTimeText = function ($from, $to) {

                    $diff = $from->diffInMinutes($to);
                    $hours = floor($diff / 60);
                    $minutes = $diff % 60;

                    return trim(($hours > 0 ? "{$hours} hora(s) " : '') . ($minutes > 0 ? "{$minutes} minuto(s)" : ''));
                };

                $dorToracicaResultadosEletrocardiograma = collect();
                $dorToracicaTempoChegadaAteTriagem = null;
                $dorToracicaTempoTriagemAteResultadoEletrocardiograma = null;
                $dorToracicaTempoTriagemAteAtendimentoMedico = null;
                $dorToracicaTempoAtendimentoAteFinalizacaoProtocolo = null;
                $dorToracicaSinaisInstabilidade = collect();

                if (!is_null($formularioDorToracica)) {

                    if ($formularioDorToracica->protocolo_finalizado) {

                        $dorToracicaTempoAtendimentoAteFinalizacaoProtocolo = $dorToracicaGetTimeText(
                            new Carbon($atendimento->recepcao->atendido_em),
                            $formularioDorToracica->protocolo_finalizado_em
                        );
                    }

                    $dorToracicaSinaisInstabilidade = $formularioDorToracica->sinaisInstabilidade()->pluck('id');

                    $dorToracicaResultadosEletrocardiograma = $formularioDorToracica->resultadosEletrocardiograma()
                        ->orderBy('created_at')
                        ->get();

                    $dorToracicaAtendimentoTriagem = $atendimento->atendimentosTriagem()
                        ->where('created_at', '<=', $formularioDorToracica->created_at)
                        ->orderByDesc('created_at')
                        ->first();

                    if (!is_null($dorToracicaAtendimentoTriagem)) {

                        $dorToracicaTempoChegadaAteTriagem = $dorToracicaGetTimeText(
                            new Carbon($atendimento->recepcao->atendido_em),
                            $dorToracicaAtendimentoTriagem->created_at
                        );

                        if ($dorToracicaResultadosEletrocardiograma->isNotEmpty()) {

                            $dorToracicaTempoTriagemAteResultadoEletrocardiograma = $dorToracicaGetTimeText(
                                $dorToracicaAtendimentoTriagem->created_at,
                                $dorToracicaResultadosEletrocardiograma->first()->created_at
                            );
                        }

                        $dorToracicaAtendimentoMedico = $atendimento->atendimentosMedico()
                            ->where('created_at', '>=', $dorToracicaAtendimentoTriagem->created_at)
                            ->orderBy('created_at')
                            ->first();

                        if (!is_null($dorToracicaAtendimentoMedico)) {

                            $dorToracicaTempoTriagemAteAtendimentoMedico = $dorToracicaGetTimeText(
                                $dorToracicaAtendimentoTriagem->created_at,
                                $dorToracicaAtendimentoMedico->created_at
                            );
                        }
                    }
                }

                $dorToracicaTempoTotalAtendimento = $dorToracicaGetTimeText(
                    new Carbon($atendimento->recepcao->atendido_em),
                    Carbon::now()
                );
            }

            $model = array_merge($model, [
                'dor_toracica' => $atendimento->dor_toracica,
                'proxima_reavaliacao' => null,
                'data_proxima_reavaliacao' => Carbon::now()->format('d/m/Y'),
                'hora_proxima_reavaliacao' => null,
                'atendimento_id' => $atendimento->id,
                'classificacao_risco_id' => $ultimaClassificacaoRisco->classificacaoRisco->id ?? null,
                'faa' => $faa,
                'data_atendimento' => $atendimento->created_at->format('d/m/Y'),
                'alergias' => $alergias,
                'fatores_risco' => $this->getCidadaoFatoresRisco($atendimento),
                'fator_risco_outro' => $faa->paciente->cidadao->fator_risco_outro,
                'sinais_vitais' => [],
                'anotacoes' => [],
                'avaliacao_antropometrica' => $this->getAvaliacaoAntropometrica(
                    $atendimento->avaliacoesAntropometricas()->orderByDesc('created_at')->first()
                ),
                'exibirFatorRiscoGestante' => $exibirFatorRiscoGestante,
                'cid' => $cidPrincipal->cid ?? null,
                'medicamentos_uso' => null,
                'procedimentos' => [],
                'encaminhamentos' => [],
                'pedidos_exames' => [],
                'evolucao' => null,
                'atendimento_geral' => null,
                'queixa_principal_duracao' => null,
                'historia' => null,
                'exame_fisico' => null,
                'diagnostico' => null,
                'conduta' => null,
                'observacoes_enfermagem' => null,
                'servicos_enfermagem' => [],
                'observacoes' => null,
                'centro_custo_id_para' => null,
                'solicitou_reavaliacao' => null,
                'prescricoes_internas' => [],
                'receitas_medicas_assinadas' => [],
                'receita_medica' => [
                    'is_assinada' => false,
                    'medicamentos' => []
                ],
                'medicamentos_uso_continuo' => $medicamentosUsoContinuo,
                'gestacao' => $this->getGestacao($atendimento),
                'finalizacao' => [
                    'desfecho_id' => null,
                    'evasao' => [
                        'motivo' => null,
                    ],
                    'encaminhamento_hospitalar' => [
                        'unidade_id' => null,
                        'unidade_outra' => false,
                        'unidade_nome' => null,
                        'quarto' => null,
                        'leito' => null,
                        'cid' => null,
                        'medico_hospitalar' => null,
                        'observacoes' => null,
                    ],
                    'obito' => [
                        'data_obito' => null,
                        'hora_obito' => null,
                        'obito_em' => null,
                        'declaracao' => null,
                        'causa' => null,
                        'cid' => null,
                    ]
                ],
                'orientacoes' => $atendimentoMedico->orientacoes ?? null,
                'acidente_trabalho' => AcidenteTrabalhoService::getAcidenteTrabalho($atendimento->faa),
                'atestado' => [
                    'nome' => $atendimentoMedico->atestado->nome ?? null,
                    'paciente' => $atendimentoMedico->atestado->paciente ?? 0,
                    'imprime_cid' => $atendimentoMedico->atestado->imprime_cid ?? true,
                    'modelo_id' => $atendimentoMedico->atestado->modelo_id ?? AtestadoModelo::PADRAO,
                    'dias' => $atendimentoMedico->atestado->dias ?? null,
                    'quantidade_horas' => $atendimentoMedico->atestado->quantidade_horas ?? null,
                    'horario_inicial' => $atendimentoMedico->atestado->horario_inicial ?? null,
                    'documento_tipo_id' => $atendimentoMedico->atestado->documento_tipo_id ?? null,
                    'documento_numero' => $atendimentoMedico->atestado->documento_numero ?? null,
                    'cpf_acompanhante' => $atendimentoMedico->atestado->cpf_acompanhante ?? null,
                ],
                'declaracoes_comparecimento' => [],
                'doencas_cronicas' => null,
                'escalas_coma_glasgow' => [],
                'dor_toracica_protocolo_finalizado' => $dorToracicaProtocoloFinalizado ?? null,
                'dor_toracica_protocolo_tem_prosseguimento' => $dorToracicaProtocoloTemProsseguimento ?? null,
                'dor_toracica_data_hora_chegada' => (new Carbon($atendimento->recepcao->atendido_em))->format('d/m/Y H:i:s'),
                'dor_toracica_tempo_chegada_ate_triagem' => $dorToracicaTempoChegadaAteTriagem ?? null,
                'dor_toracica_tempo_triagem_ate_resultado_eletrocardiograma' => $dorToracicaTempoTriagemAteResultadoEletrocardiograma ?? null,
                'dor_toracica_tempo_triagem_ate_atendimento_medico' => $dorToracicaTempoTriagemAteAtendimentoMedico ?? null,
                'dor_toracica_tempo_total_atendimento' => $dorToracicaTempoTotalAtendimento ?? null,
                'dor_toracica_tempo_atendimento_ate_finalizacao_protocolo' => $dorToracicaTempoAtendimentoAteFinalizacaoProtocolo ?? null,
                'dor_toracica_data_sintoma' => $data_sintoma ?? null,
                'dor_toracica_hora_sintoma' => $hora_sintoma ?? null,
                'dor_toracica_data_ecg_admissao' => $data_ecg_admissao ?? null,
                'dor_toracica_hora_ecg_admissao' => $hora_ecg_admissao ?? null,
                'dor_toracica_caracteristica_dor' => $dorToracicaRelacionada  ?? null,
                'dor_toracica_localizacao_dor' => $dorToracicaRelacionada  ?? null,
                'dor_toracica_fator_descadeante' => $dorToracicaRelacionada  ?? null,
                'dor_toracica_duracao_dor' => $dorToracicaRelacionada  ?? null,
                'dor_toracica_fatores_riscos' => $dorToracicaRelacionada  ?? null,
                'dor_toracica_dispneia' => $dispneia ?? null,
                'dor_toracica_resultado_eletrocardiograma' => null,
                'dor_toracica_resultados_eletrocardiograma' => ($dorToracicaResultadosEletrocardiograma ?? collect())
                    ->map(fn ($resultado) => [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $resultado->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $resultado->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $resultado->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'data_hora' => $resultado->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $resultado->descricao,
                    ]),
                'dor_toracica_permite_resultado_eletrocardiograma' => isset($dorToracicaResultadosEletrocardiograma)
                    ? self::hasEletrocardiogramaRealizado($atendimento, $dorToracicaResultadosEletrocardiograma, $formularioDorToracica)
                    : false,
                'dor_toracica_tem_contra_indicacao_trombolitico' => $dorToracicaTemContraIndicacaoTrombolitico ?? null,
                'dor_toracica_contra_indicacao_trombolitico_motivo' => $dorToracicaContraIndicacaoTromboliticoMotivo ?? null,
                'dor_toracica_sinais_instabilidade' => $dorToracicaSinaisInstabilidade ?? [],
                'cancelamento_desfecho' => false,
            ]);
        }

        return [
            'model' => $model,
            'form' => $this->getDadosForm($atendimento, $centroCustoLogado),
            'additionals' => [
                'timeline' => AtendimentoService::getTimelineItems($id),
                'from_observacao' => Fila::findOrFail($id)->centroCusto->setor->tipo_id === SetorTipo::OBSERVACAO,
                'termos_invalidos' => TermoInvalido::all()->map(fn ($termo) => $termo->descricao),
                'assinatura_eletronica_ativa' => Parametrizacao::first()->assinatura_eletronica ?? false,
            ]
        ];
    }

    private function hasEletrocardiogramaRealizado($atendimento, $dorToracicaResultadosEletrocardiograma, $formularioDorToracica)
    {
        $quantidadeEletrocardiogramasRealizados = $atendimento->atendimentosMedico()
            ->whereHas('pedidosExames', fn ($q) => $q
                ->where('created_at', '>=', $formularioDorToracica->created_at)
                ->whereHas('exames', fn ($q) => $q
                    ->whereHas('exame', fn ($q) => $q
                        ->where('codigo', ProcedimentoEnum::ELETROCARDIOGRAMA)
                    )
                    ->where('status_id', ExameStatusEnum::REALIZADO)
                )
            )
            ->count();

        return $dorToracicaResultadosEletrocardiograma->count() < $quantidadeEletrocardiogramasRealizados;
    }

    public function getMedicosAtendimento($atendimentoId)
    {
        $usuarios = collect();

        Atendimento::findOrFail($atendimentoId)
            ->atendimentosMedico
            ->each(function ($atendimentoMedico) use ($usuarios) {

                $usuario = $atendimentoMedico->createdLotacao->usuario;

                if (!$usuarios->contains('id', $usuario->id)) {

                    $usuarios->push([
                        'id' => $usuario->id,
                        'nome' => $usuario->cidadao->nome
                    ]);
                }
            });

        return response()->json($usuarios->sortBy('nome')->values(), Response::HTTP_OK);
    }

    public function getProfissionaisAtendimento($atendimentoId)
    {
        $usuarios = collect();

        $atendimento = Atendimento::findOrFail($atendimentoId);

        $atendimento->atendimentosMedico
            ->each(function ($atendimentoMedico) use ($usuarios) {

                $usuario = $atendimentoMedico->createdLotacao->usuario;

                if (!$usuarios->contains('id', $usuario->id)) {

                    $usuarios->push([
                        'id' => $usuario->id,
                        'nome' => $usuario->cidadao->nome
                    ]);
                }
            });

        $atendimento->atendimentosEnfermagem
            ->each(function ($atendimentoEnfermagem) use ($usuarios) {

                $usuario = $atendimentoEnfermagem->createdLotacao->usuario;

                if (!$usuarios->contains('id', $usuario->id)) {

                    $usuarios->push([
                        'id' => $usuario->id,
                        'nome' => $usuario->cidadao->nome
                    ]);
                }
            });

        $atendimento->atendimentosExameImagem
            ->each(function ($atendimentoExameImagem) use ($usuarios) {

                $usuario = $atendimentoExameImagem->createdLotacao->usuario;

                if (!$usuarios->contains('id', $usuario->id)) {

                    $usuarios->push([
                        'id' => $usuario->id,
                        'nome' => $usuario->cidadao->nome
                    ]);
                }
            });

        $atendimento->pacienteObservacoes
            ->each(function ($observacoes) use ($usuarios) {

                $usuario = $observacoes->createdLotacao->usuario;

                if (!$usuarios->contains('id', $usuario->id)) {

                    $usuarios->push([
                        'id' => $usuario->id,
                        'nome' => $usuario->cidadao->nome
                    ]);
                }
            });

        $atendimento->atendimentosTriagem
            ->each(function ($atendimentoTriagem) use ($usuarios) {

                $usuario = $atendimentoTriagem->createdLotacao->usuario;

                if (!$usuarios->contains('id', $usuario->id)) {

                    $usuarios->push([
                        'id' => $usuario->id,
                        'nome' => $usuario->cidadao->nome
                    ]);
                }
            });

        if ($atendimento->recepcao) {

            $usuario = $atendimento->recepcao->createdLotacao->usuario;

            if (!$usuarios->contains('id', $usuario->id)) {

                $usuarios->push([
                    'id' => $usuario->id,
                    'nome' => $usuario->cidadao->nome
                ]);
            }
        }

        return response()->json($usuarios->sortBy('nome')->values(), Response::HTTP_OK);
    }

    private function getGestacao($atendimento)
    {
        $gestacao = $atendimento->gestacoes()->orderByDesc('created_at')->first();
        $gestacaoPaciente = $atendimento->faa->paciente->dum;

        return [
            'dpp' => $gestacaoPaciente && $gestacaoPaciente->data_possivel_parto
                ? Carbon::create($gestacaoPaciente->data_possivel_parto)->format('d/m/Y')
                : $gestacao->dpp ?? null,
            'dum_min_date' => $atendimento->created_at->subDays(308)->format('d/m/Y'),
            'dum_max_date' => $atendimento->created_at->format('d/m/Y'),
            'dum' => $gestacaoPaciente && $gestacaoPaciente->data_ultima_menstruacao
                ? $gestacaoPaciente->data_ultima_menstruacao
                : $gestacao->dum ?? null,
            'gestante' => $atendimento->faa->paciente->cidadao->fatoresRisco->contains(FatorRiscoEnum::GESTANTE)
                ?? $gestacao->gestante ?? false,
            'idade_gestacional' => [
                'dias' => $gestacaoPaciente && $gestacaoPaciente->idade_gestacional_dias
                    ? $gestacaoPaciente->idade_gestacional_dias
                    : $gestacao->idade_gestacional['dias'] ?? null,
                'semanas' => $gestacaoPaciente && $gestacaoPaciente->idade_gestacional_semanas
                    ? $gestacaoPaciente->idade_gestacional_semanas
                    : $gestacao->idade_gestacional['semanas'] ?? null,
            ],
        ];
    }

    public function getDeclaracoesComparecimento($atendimentoId)
    {
        $declaracoesComparecimento = [];

        $atendimento = Atendimento::findOrFail($atendimentoId);

        $atendimento->atendimentosMedico
            ->each(function ($atendimentoMedico) {

                foreach ($atendimentoMedico->declaracoesComparecimento as $declaracaoComparecimento) {
                    $declaracoesComparecimento[] = [
                        'id' => $declaracaoComparecimento->id,
                        'tipo_id' => $declaracaoComparecimento->tipo_id ?? null,
                        'data_de' => $declaracaoComparecimento->de->format('d/m/Y') ?? null,
                        'hora_de' => $declaracaoComparecimento->de->format('H:i:s') ?? null,
                        'data_ate' => $declaracaoComparecimento->ate->format('d/m/Y') ?? null,
                        'hora_ate' => $declaracaoComparecimento->ate->format('H:i:s') ?? null,
                    ];
                }
            });

        $atendimento->atendimentosEnfermagem
            ->each(function ($atendimentoEnfermagem) {

                foreach ($atendimentoEnfermagem->declaracoesComparecimento as $declaracaoComparecimento) {
                    $declaracoesComparecimento[] = [
                        'id' => $declaracaoComparecimento->id,
                        'tipo_id' => $declaracaoComparecimento->tipo_id ?? null,
                        'data_de' => $declaracaoComparecimento->de->format('d/m/Y') ?? null,
                        'hora_de' => $declaracaoComparecimento->de->format('H:i:s') ?? null,
                        'data_ate' => $declaracaoComparecimento->ate->format('d/m/Y') ?? null,
                        'hora_ate' => $declaracaoComparecimento->ate->format('H:i:s') ?? null,
                    ];
                }
            });

        $atendimento->atendimentosExameImagem
            ->each(function ($atendimentoExameImagem) {

                foreach ($atendimentoExameImagem->declaracoesComparecimento as $declaracaoComparecimento) {
                    $declaracoesComparecimento[] = [
                        'id' => $declaracaoComparecimento->id,
                        'tipo_id' => $declaracaoComparecimento->tipo_id ?? null,
                        'data_de' => $declaracaoComparecimento->de->format('d/m/Y') ?? null,
                        'hora_de' => $declaracaoComparecimento->de->format('H:i:s') ?? null,
                        'data_ate' => $declaracaoComparecimento->ate->format('d/m/Y') ?? null,
                        'hora_ate' => $declaracaoComparecimento->ate->format('H:i:s') ?? null,
                    ];
                }
            });

        $atendimento->pacienteObservacoes
            ->each(function ($observacoes) {

                foreach ($observacoes->declaracoesComparecimento as $declaracaoComparecimento) {
                    $declaracoesComparecimento[] = [
                        'id' => $declaracaoComparecimento->id,
                        'tipo_id' => $declaracaoComparecimento->tipo_id ?? null,
                        'data_de' => $declaracaoComparecimento->de->format('d/m/Y') ?? null,
                        'hora_de' => $declaracaoComparecimento->de->format('H:i:s') ?? null,
                        'data_ate' => $declaracaoComparecimento->ate->format('d/m/Y') ?? null,
                        'hora_ate' => $declaracaoComparecimento->ate->format('H:i:s') ?? null,
                    ];
                }
            });

        $atendimento->atendimentosTriagem
            ->each(function ($atendimentoTriagem) {

                foreach ($atendimentoTriagem->declaracoesComparecimento as $declaracaoComparecimento) {
                    $declaracoesComparecimento[] = [
                        'id' => $declaracaoComparecimento->id,
                        'tipo_id' => $declaracaoComparecimento->tipo_id ?? null,
                        'data_de' => $declaracaoComparecimento->de->format('d/m/Y') ?? null,
                        'hora_de' => $declaracaoComparecimento->de->format('H:i:s') ?? null,
                        'data_ate' => $declaracaoComparecimento->ate->format('d/m/Y') ?? null,
                        'hora_ate' => $declaracaoComparecimento->ate->format('H:i:s') ?? null,
                    ];
                }
            });

        if ($atendimento->recepcao) {

            foreach ($atendimento->recepcao->declaracoesComparecimento as $declaracaoComparecimento) {
                $declaracoesComparecimento[] = [
                    'id' => $declaracaoComparecimento->id,
                    'tipo_id' => $declaracaoComparecimento->tipo_id ?? null,
                    'data_de' => $declaracaoComparecimento->de->format('d/m/Y') ?? null,
                    'hora_de' => $declaracaoComparecimento->de->format('H:i:s') ?? null,
                    'data_ate' => $declaracaoComparecimento->ate->format('d/m/Y') ?? null,
                    'hora_ate' => $declaracaoComparecimento->ate->format('H:i:s') ?? null,
                ];
            }
        }

        return response()->json($declaracoesComparecimento, Response::HTTP_OK);
    }

    public function storeDeclaracaoComparecimento()
    {
        $data = $this->prepareDeclaracoesComparecimentoData([
            'declaracoes_comparecimento' => [request()->except(['atendimento_id', 'medico_id'])]
        ])[0];

        $declaracao = AtendimentoMedico::where('atendimento_id', request()->atendimento_id)
            ->whereHas('createdLotacao', function ($query) {

                $query->where('usuario_id', request()->medico_id);
            })
            ->orderBy('id')
            ->first();

        if ($declaracao) {

            $declaracao = $declaracao->declaracoesComparecimento()->create($data);
        } else {

            $declaracao = AtendimentoEnfermagem::where('atendimento_id', request()->atendimento_id)
                ->whereHas('createdLotacao', function ($query) {

                    $query->where('usuario_id', request()->medico_id);
                })
                ->orderBy('id')
                ->first();

            if ($declaracao) {

                $declaracao = $declaracao->declaracoesComparecimento()->create($data);
            } else {

                $declaracao = AtendimentoExameImagem::where('atendimento_id', request()->atendimento_id)
                    ->whereHas('createdLotacao', function ($query) {

                        $query->where('usuario_id', request()->medico_id);
                    })
                    ->orderBy('id')
                    ->first();

                if ($declaracao) {

                    $declaracao = $declaracao->declaracoesComparecimento()->create($data);
                } else {

                    $declaracao = PacienteObservacao::where('atendimento_id', request()->atendimento_id)
                        ->whereHas('createdLotacao', function ($query) {

                            $query->where('usuario_id', request()->medico_id);
                        })
                        ->orderBy('id')
                        ->first();

                    if ($declaracao) {

                        $declaracao = $declaracao->declaracoesComparecimento()->create($data);
                    } else {

                        $declaracao = AtendimentoTriagem::where('atendimento_id', request()->atendimento_id)
                            ->whereHas('createdLotacao', function ($query) {

                                $query->where('usuario_id', request()->medico_id);
                            })
                            ->orderBy('id')
                            ->first();

                        if ($declaracao) {

                            $declaracao = $declaracao->declaracoesComparecimento()->create($data);
                        } else {

                            $declaracao = Recepcao::where('atendimento_id', request()->atendimento_id)
                                ->whereHas('createdLotacao', function ($query) {

                                    $query->where('usuario_id', request()->medico_id);
                                })
                                ->orderBy('id')
                                ->first();

                            if ($declaracao) {

                                $declaracao = $declaracao->declaracoesComparecimento()->create($data);
                            }
                        }
                    }
                }
            }
        }

        return response()->json($declaracao, Response::HTTP_CREATED);
    }

    public function store(MedicoRequest $request)
    {
        $this->auth(__FUNCTION__);

        $atendimentoMedico = new AtendimentoMedico;
        $params = $request->all();

        DB::transaction(function () use ($atendimentoMedico, $params) {

            $atendimento = Atendimento::findOrFail($params['atendimento_id']);
            $isReavaliacao = $atendimento->atendimentosMedico()->get()->isNotEmpty();
            $centroCustoPara = isset($params['centro_custo_id_para']) ? CentroCusto::find($params['centro_custo_id_para']) : null;
            $centroCustoSetorTipo = $centroCustoPara ? $centroCustoPara->setor->tipo_id : null;

            $fila = Fila::findOrFail($atendimento->fila_id);

            if ($params['cancelamento_desfecho'] == true) {

                $atendimento->faa->update([
                    'canceled_desfecho_lotacao_id' => auth()->payload()->get('lotacao_id'),
                ]);
            }

            if (($params['data_hora_proxima_reavaliacao'] ?? null) || ($centroCustoSetorTipo && $centroCustoSetorTipo == SetorTipo::OBSERVACAO)) {

                $procedimentosAnteriores = $atendimento->procedimentos()->pluck('procedimento_id')->toArray();
                $primeiroAtendimento = $atendimento->pacienteObservacoes ? $atendimento->pacienteObservacoes()->orderBy('created_at')->first() : null;
                $tempoAtendimento = null;

                if ( !is_null($primeiroAtendimento) ) {
                    $tempoAtendimento = $primeiroAtendimento->created_at->diff(Carbon::now());
                }

                $sigtapProcedimento = Procedimento::where('codigo', ProcedimentoEnum::ATEND_URG_OBS_ATE_24_HORAS_ATENCAO_ESPECIALIZADA)->orderByDesc('competencia_id')->firstOrFail();

                if (!in_array($sigtapProcedimento->id, $procedimentosAnteriores) || (!is_null($tempoAtendimento) && $tempoAtendimento->d >= 1)) {

                    array_push($params['procedimentos'], [
                        'procedimento_id' => $sigtapProcedimento->id,
                        'cid_principal_id' => $sigtapProcedimento->cidsPrincipais()->pluck('id')->first(),
                        'quantidade' => 1,
                        'is_parametrizado' => $sigtapProcedimento->parametrizacaoProcedimento()->exists(),
                    ]);
                }
            }

            $alergiasData = $this->prepareAlergiasData($params);
            $atendimento->faa->paciente->cidadao->alergias()->sync($alergiasData);

            $medicamentosUsoContinuoData = $this->prepareMedicamentosUsoContinuoData($params);
            $atendimento->faa->paciente->cidadao->medicamentosUsoContinuo()->sync($medicamentosUsoContinuoData);

            $atendimento->faa->paciente->cidadao->fatoresRisco()->sync($params['fatores_risco'] ?? []);
            $this->handleFatorRiscoOutro($atendimento, $params);

            $atendimentoMedico->fill($this->prepareAtendimentoMedicoData($params, $atendimento, $isReavaliacao));
            $atendimento->atendimentosMedico()->save($atendimentoMedico);

            $cidData = $this->prepareCidData($params, $atendimentoMedico);

            if (!is_null($cidData)) {

                $atendimento->cids()->create($cidData);
            }

            $classificacaoRiscoData = $this->prepareClassificacaoRiscoData($params, $atendimentoMedico);
            $atendimento->classificacoesRisco()->create($classificacaoRiscoData);

            $gestacaoData = $this->prepareGestacaoData($params, $atendimentoMedico);

            if (!is_null($gestacaoData)) {

                $atendimento->gestacoes()->create($gestacaoData);

                if ($params['gestacao']['dum']) {

                    $atendimento->faa->paciente->dum()->updateOrCreate(
                        ['paciente_id' => $atendimento->faa->paciente->id],
                        ['data_ultima_menstruacao' => $params['gestacao']['dum']]
                    );
                }

                if (!$atendimento->faa->paciente->cidadao->fatoresRisco->contains(FatorRiscoEnum::GESTANTE)) {

                    $atendimento->faa->paciente->cidadao->fatoresRisco()->attach(FatorRiscoEnum::GESTANTE);
                }
            }

            $medicamentosUsoData = $this->prepareMedicamentosUsoData($params, $atendimentoMedico);

            if (!empty($medicamentosUsoData)) {

                $atendimento->medicamentosUso()->create($medicamentosUsoData);
            }

            $sinaisVitaisData = $this->prepareSinaisVitaisData($params, $atendimentoMedico);

            if (!empty($sinaisVitaisData)) {

                $atendimento->sinaisVitais()->createMany($sinaisVitaisData);
            }

            $avaliacaoAntropometricaData = $this->prepareAvaliacaoAntropometricaData($params, $atendimentoMedico);

            if (!is_null($avaliacaoAntropometricaData)) {

                $ultimaAvaliacao = $atendimentoMedico->atendimento->avaliacoesAntropometricas()
                    ->orderByDesc('created_at')
                    ->first();

                if (!(!is_null($ultimaAvaliacao)
                    && $avaliacaoAntropometricaData['massa'] == $ultimaAvaliacao->massa
                    && $avaliacaoAntropometricaData['massa_unidade_medida_id'] == $ultimaAvaliacao->massa_unidade_medida_id
                    && $avaliacaoAntropometricaData['altura_tipo_medida_id'] == $ultimaAvaliacao->altura_tipo_medida_id
                    && $avaliacaoAntropometricaData['altura'] == $ultimaAvaliacao->altura
                    && $avaliacaoAntropometricaData['altura_unidade_medida_id'] == $ultimaAvaliacao->altura_unidade_medida_id)
                ) {

                    $atendimento->avaliacoesAntropometricas()->create($avaliacaoAntropometricaData);
                }
            }

            $observacaoData = $this->prepareObservacaoData($params, $atendimentoMedico);

            if (!is_null($observacaoData)) {

                $atendimento->observacoes()->create($observacaoData);
            }

            $this->handleDorToracica($params, $atendimentoMedico);

            $doencasCronicasData = $this->prepareDoencasCronicasData($params);

            if (!is_null($doencasCronicasData)) {
                $atendimento->faa->paciente->cidadao->doencasCronicas()->create($doencasCronicasData);
            }

            $atestadoData = $this->prepareAtestadoData($params);

            if (!is_null($atestadoData)) {

                $atendimentoMedico->atestado()->create($atestadoData);
            }

            $encaminhamentosData = $this->prepareEncaminhamentosData($params);

            if (!empty($encaminhamentosData)) {

                $atendimentoMedico->encaminhamentos()->createMany($encaminhamentosData);
            }

            $declaracoesComparecimentoData = $this->prepareDeclaracoesComparecimentoData($params);

            if (!empty($declaracoesComparecimentoData)) {

                $atendimentoMedico->declaracoesComparecimento()->createMany($declaracoesComparecimentoData);
            }

            $receitaMedicaData = $this->prepareReceitaMedicaData($params);

            if (!empty($receitaMedicaData)) {

                $this->storeReceitaMedica($receitaMedicaData, $atendimentoMedico, $params['receitas_medicas_assinadas']);
            }

            $prescricoesInternasData = $this->preparePrescricoesInternasData($params, $atendimentoMedico);

            if (!empty($prescricoesInternasData)) {

                $this->storePrescricoesInternas($prescricoesInternasData, $atendimentoMedico);
            }

            $raatData = $this->prepareRaatData($params, $atendimentoMedico);

            if (!is_null($raatData)) {

                $this->storeRaat($raatData, $atendimento);

                if($params['raat']['tipo_formulario_acidente_trabalho'] != TipoFormularioAcidenteTrabalho::RAAT) {
                    $this->storeCat($params);
                }
            }

            $procedimentosData = $this->prepareProcedimentosData($params, $atendimentoMedico, $isReavaliacao);

            if (!empty($procedimentosData)) {

                $atendimento->procedimentos()->createMany($procedimentosData);
            }

            $pedidoExameData = $this->preparePedidoExameData($params, $atendimento);

            if (!empty($pedidoExameData)) {

                $this->storePedido($pedidoExameData, $atendimentoMedico);
            }

            if (isset($params['servicos_enfermagem'])) {

                $atendimentoMedico->servicosEnfermagem()->createMany($params['servicos_enfermagem']);
            }

            if (isset($request['escala_coma_glasgow'])) {
                $atendimentoMedico->escalasComaGlasgow()->createMany($request['escala_coma_glasgow']);
            }

            if ($this->isFromObservacao($atendimento)) {

                $procedimentoObservacao = new ProcedimentoObservacaoService(
                    $this->getCurrentLotacao(),
                    $atendimentoMedico
                );

                $procedimentoObservacao->save();
            }

            if (isset($params['desfecho'])) {

                $this->storeDesfecho($params['desfecho'], $atendimentoMedico);
            }

            if (isset($params['finalizacao'])) {

                $atendimentoMedico->desfecho_id = $params['finalizacao']['desfecho_id'];

                $this->storeFinalizacao($params['finalizacao'], $atendimentoMedico);

                $atendimentoMedico->save();
            }
            else if (!is_null($params['centro_custo_id_para'] ?? null)) {

                FilaService::forward([
                    'centro_custo_id_para' => $params['centro_custo_id_para'],
                    'prioridade_id' => $fila['prioridade_id']
                ], $atendimento->fila_id);
            }
        });

        $atendimentoMedico->refresh();

        $atendimentoMedico->faa_id = $atendimentoMedico->atendimento->faa_id;

        $atendimentoMedico->impressoes = ImpressaoService::getImpressoes(
            $atendimentoMedico->atendimento_id,
        );

        $atendimentoMedico->assinar = Parametrizacao::first()->assinatura_eletronica ?? false;

        return response()->json($atendimentoMedico, Response::HTTP_CREATED);
    }

    private function storeReceitaMedica($receitaMedica, $atendimentoMedico, $receitasMedicasAssinadasAgrupadas)
    {
        $receita = $atendimentoMedico->receita()->create($receitaMedica);

        foreach ($receitaMedica['medicamentos'] as $item) {

            $receita->medicamentos()->create($item);
        }

        foreach ($receitasMedicasAssinadasAgrupadas as $i => $receitasMedicasAssinadas) {

            $ordem = $i + 1;

            foreach ($receitasMedicasAssinadas as $receitaMedicaAssinada) {

                $receita->receitasAssinadas()->create([
                    'ordem' => $ordem,
                    'receita' => $receitaMedicaAssinada,
                ]);
            }
        }
    }

    private function storePrescricoesInternas(array $prescricoesInternas, AtendimentoMedico $atendimentoMedico)
    {
        foreach ($prescricoesInternas as $params) {

            $prescricaoInterna = $atendimentoMedico->prescricoesInternas()->create($params);

            foreach ($params['medicamentos'] as $medicamento) {
                $item = $prescricaoInterna->medicamentos()->create($medicamento);

                $frequenciaQuantidadeVezes = $prescricaoInterna->frequencia_quantidade_vezes;

                if ($prescricaoInterna->doseUnica) {
                    $frequenciaQuantidadeVezes = 1;
                }

                for ($i = 0; $i < $frequenciaQuantidadeVezes; $i++) {
                    $aplicacao = [
                        'status_id' => ExameStatusEnum::SOLICITADO,
                    ];

                    $item->aplicacoes()->create($aplicacao);
                }
            }
        }
    }

    private function storeRaat(array $raat, Atendimento $atendimento)
    {
        Raat::where('id', $raat['id'])->update(['acidente_tipo_id' => $raat['acidente_tipo_id']]);
        $parecerMedico = $atendimento->faa->raat->pareceresMedico()->create($raat);

        $parecerMedico->partesCorpoAtingidas()->sync($raat['partes_corpo_atingidas']);
        $parecerMedico->causasAcidente()->sync($raat['causas_acidente']);
        $parecerMedico->diagnosticos()->sync($raat['diagnosticos']);
    }

    private function storeCat(array $params) {

        $params = $params['raat'];

        $cat = [
            'paciente_sofreu_acidente_trabalho' => $params['paciente_sofreu_acidente_trabalho'],
            'paciente_portador_doenca_ocupacional' => $params['paciente_portador_doenca_ocupacional'],
            'paciente_precisa_internacao' => $params['paciente_precisa_internacao'],
            'dias_afastamento' => $params['dias_afastamento'],
        ];

        Cat::where('raat_id', $params['id'])->update($cat);
    }

    private function storeDesfecho($desfecho, $atendimentoMedico)
    {
        switch ($desfecho['id']) {

            case Desfecho::EVASAO: {

                $atendimentoMedico->motivo_evasao = $desfecho['evasao']['motivo'];

                break;
            }
            case Desfecho::OBITO: {

                $obitoService = new ObitoService($atendimentoMedico->atendimento->faa->paciente->cidadao);

                $obitoService->save(
                    Carbon::createFromFormat('d/m/Y H:i', $desfecho['obito']['obito_em']),
                    $desfecho['obito']['declaracao'],
                    $desfecho['obito']['causa'],
                    $desfecho['obito']['cid_id'],
                    $atendimentoMedico->createdLotacao->usuario_id
                );

                $cadastroIndividual = CadastroIndividual::where('paciente_id', $atendimentoMedico->atendimento->faa->paciente->id)->first();
                $cadastroCidadaoInformacaoSocial = PacienteInformacaoSocial::where('paciente_id', $atendimentoMedico->atendimento->faa->paciente->id)->first();

                if($cadastroIndividual){
                        $cadastroIndividual->update([
                            'data_usuario_responsavel' => Carbon::now(),
                            'saida_cidadao_id' => SaidaCidadao::OBITO
                        ]);
                }

                if($cadastroCidadaoInformacaoSocial){
                        $cadastroCidadaoInformacaoSocial->update([
                            'saida_cidadao_id' => SaidaCidadao::OBITO
                        ]);
                }

                self::saveHistorico($atendimentoMedico->atendimento->faa->paciente->id);

                break;
            }
            case Desfecho::ENCAMINHAMENTO_HOSPITALAR: {

                $atendimentoMedico->encaminhamentoHospitalar()->create([
                    'atendimento_id' => $atendimentoMedico->atendimento->id,
                    'usuario_id' => $atendimentoMedico->createdLotacao->usuario_id,
                    'unidade_id' => $desfecho['encaminhamento_hospitalar']['unidade_id'] ?? null,
                    'unidade_nome' => $desfecho['encaminhamento_hospitalar']['unidade_nome'] ?? null,
                    'quarto' => $desfecho['encaminhamento_hospitalar']['quarto'] ?? null,
                    'leito' => $desfecho['encaminhamento_hospitalar']['leito'] ?? null,
                    'cid_id' => $desfecho['encaminhamento_hospitalar']['cid_id'] ?? null,
                    'medico_hospitalar' => $desfecho['encaminhamento_hospitalar']['medico_hospitalar'] ?? null,
                    'observacoes' => $desfecho['encaminhamento_hospitalar']['observacoes'] ?? null,
                ]);

                break;
            }
        }

        $atendimentoMedico->desfecho_id = $desfecho['id'];
        $atendimentoMedico->save();
    }

    private function storeFinalizacao(array $params, AtendimentoMedico $atendimentoMedico)
    {
        switch ($params['desfecho_id']) {

            case Desfecho::EVASAO: {

                FilaService::evade([
                    'motivo_evasao' => $params['evasao']['motivo']
                ], $atendimentoMedico->atendimento->fila_id);

                break;
            }
            case Desfecho::OBITO: {

                $obitoService = new ObitoService($atendimentoMedico->atendimento->faa->paciente->cidadao);

                $obitoService->save(
                    Carbon::createFromFormat('d/m/Y H:i', $params['obito']['obito_em']),
                    $params['obito']['declaracao'],
                    $params['obito']['causa'],
                    $params['obito']['cid_id'],
                    $atendimentoMedico->createdLotacao->usuario_id
                );

                $cadastroIndividual = CadastroIndividual::where('paciente_id', $atendimentoMedico->atendimento->faa->paciente->id)->first();
                $cadastroCidadaoInformacaoSocial = PacienteInformacaoSocial::where('paciente_id', $atendimentoMedico->atendimento->faa->paciente->id)->first();

                if($cadastroIndividual){
                        $cadastroIndividual->update([
                            'data_usuario_responsavel' => Carbon::now(),
                            'saida_cidadao_id' => SaidaCidadao:: OBITO
                        ]);
                }

                if($cadastroCidadaoInformacaoSocial){
                        $cadastroCidadaoInformacaoSocial->update([
                            'saida_cidadao_id' => SaidaCidadao::OBITO
                        ]);
                }

                self::saveHistorico($atendimentoMedico->atendimento->faa->paciente->id);

                break;
            }
            case Desfecho::ENCAMINHAMENTO_HOSPITALAR: {

                $atendimentoMedico->encaminhamentoHospitalar()->create([
                    'atendimento_id' => $atendimentoMedico->atendimento->id,
                    'usuario_id' => $atendimentoMedico->createdLotacao->usuario_id,
                    'unidade_id' => $params['encaminhamento_hospitalar']['unidade_id'] ?? null,
                    'unidade_nome' => $params['encaminhamento_hospitalar']['unidade_nome'] ?? null,
                    'quarto' => $params['encaminhamento_hospitalar']['quarto'] ?? null,
                    'leito' => $params['encaminhamento_hospitalar']['leito'] ?? null,
                    'cid_id' => $params['encaminhamento_hospitalar']['cid_id'] ?? null,
                    'medico_hospitalar' => $params['encaminhamento_hospitalar']['medico_hospitalar'] ?? null,
                    'observacoes' => $params['encaminhamento_hospitalar']['observacoes'] ?? null,
                ]);

                break;
            }
        }

        $atendimentoMedico->atendimento->faa->update([
            'desfecho_id' => $params['desfecho_id'],
            'finalizado' => true,
            'usuario_id' => $atendimentoMedico->createdLotacao->usuario_id,
            'lotacao_id' => $atendimentoMedico->createdLotacao->id,
            'data_hora_desfecho' => $atendimentoMedico->created_at
        ]);

        if ($params['desfecho_id'] != Desfecho::EVASAO) {

            FilaService::dispatch($atendimentoMedico->atendimento->fila->centroCusto);
        }
    }

    private static function saveHistorico($pacienteId)
    {

        $historico = new PacienteHistorico;
        $historico->paciente_id = $pacienteId;
        $historico->save();
    }

    private function prepareAlergiasData(array $params) : array
    {
        $alergias = [];

        foreach (($params['alergias'] ?? []) as $alergia) {

            $alergias[$alergia['alergia_id']] = [
                'criticidade_id' => $alergia['criticidade_id'],
                'reacoes_observacoes' => $alergia['reacoes_observacoes'] ?? null,
            ];
        }

        return $alergias;
    }

    private function prepareMedicamentosUsoContinuoData(array $params) : array
    {
        $medicamentos = [];

        foreach (($params['medicamentos_uso_continuo'] ?? []) as $medicamento) {

            $medicamentos[] = $medicamento['medicamento_id'];
        }

        return $medicamentos;
    }

    private function handleFatorRiscoOutro($atendimento, $params)
    {
        $atendimento->faa->paciente->cidadao->fator_risco_outro = null;

        if (in_array(FatorRiscoEnum::OUTRO, $params['fatores_risco'] ?? [])) {

            $atendimento->faa->paciente->cidadao->fator_risco_outro = $params['fator_risco_outro'] ?? null;
        }

        $atendimento->faa->paciente->cidadao->save();
    }

    private function prepareAtendimentoMedicoData($params, $atendimento, $isReavaliacao)
    {
        $centroCustoLogado = $this->getCentroCustoLogado();
        $parametrizacao = ParametrizacaoAtendimentoMedicoService::get($centroCustoLogado->infraestrutura_id);

        $isAtendimentoSimples = $parametrizacao->tipo_id === TipoAtendimento::SIMPLES;

        PlantaoService::setStatusComAtendimento($params['plantao_id']);

        $atendimentoMedico = [
            'plantao_id' => $params['plantao_id'],
            'is_observacao' => $this->isFromObservacao($atendimento),
            'simples' => $isAtendimentoSimples,
            'orientacoes' => $params['orientacoes'] ?? null,
            'desfecho_id' => $params['desfecho_id'] ?? null,
        ];

        if ($isReavaliacao) {

            $atendimentoMedico['evolucao'] = $params['evolucao'];
        }

        if ($isAtendimentoSimples) {

            $atendimentoMedico['atendimento_geral'] = $params['atendimento_geral'] ?? null;
        }
        else {

            $atendimentoMedico['queixa_principal_duracao'] = $params['queixa_principal_duracao'] ?? null;
            $atendimentoMedico['historia'] = $params['historia'] ?? null;
            $atendimentoMedico['exame_fisico'] = $params['exame_fisico'] ?? null;
            $atendimentoMedico['diagnostico'] = $params['diagnostico'] ?? null;
            $atendimentoMedico['conduta'] = $params['conduta'] ?? null;
        }

        $atendimentoMedico['observacoes_enfermagem'] = $params['observacoes_enfermagem'] ?? null;

        if ($this->isFromObservacao($atendimento)
            || (!is_null($params['centro_custo_id_para'] ?? null)
                && $this->isCentroCustoParaObservacao($params['centro_custo_id_para'])
            )) {

            if (!is_null($params['data_hora_proxima_reavaliacao'] ?? null)) {

                $atendimentoMedico['data_hora_proxima_reavaliacao'] = Carbon::createFromFormat('d/m/Y H:i', $params['data_hora_proxima_reavaliacao']);
            }
        }

        return $atendimentoMedico;
    }

    private function isCentroCustoParaObservacao($centroCustoIdPara)
    {
        $centroCustoPara = CentroCusto::findOrFail($centroCustoIdPara);

        return $centroCustoPara->setor->tipo_id === SetorTipo::OBSERVACAO;
    }

    private function isFromObservacao($atendimento)
    {
        return $atendimento->fila && $atendimento->fila->centroCusto->setor->tipo_id === SetorTipo::OBSERVACAO;
    }

    private function prepareCidData(array $params, AtendimentoMedico $atendimentoMedico) : ?array
    {
        if (!isset($params['cid_id'])) {

            return null;
        }

        return [
            'atendimento_medico_id' => $atendimentoMedico->id,
            'cid_id' => $params['cid_id'],
        ];
    }

    private function prepareClassificacaoRiscoData(array $params, AtendimentoMedico $atendimentoMedico) : array
    {
        return [
            'atendimento_medico_id' => $atendimentoMedico->id,
            'classificacao_risco_id' => $params['classificacao_risco_id'],
        ];
    }

    private function prepareGestacaoData(array $params, AtendimentoMedico $atendimentoMedico) : ?array
    {
        if (!isset($params['gestacao']) || $params['gestacao']['gestante'] == false) {

            return null;
        }

        $cidadao = $atendimentoMedico->atendimento->faa->paciente->cidadao;
        $sexoPermitido = $cidadao->sexo_id === Sexo::FEMININO;

        $idadePermitida = $cidadao->data_nascimento
            ? $cidadao->idade['anos'] >= 9 && $cidadao->idade['anos'] <= 60
            : true;

        if (!$sexoPermitido || !$idadePermitida) {

            return null;
        }

        $params = $params['gestacao'];

        return [
            'atendimento_medico_id' => $atendimentoMedico->id,
            'gestante' => $params['gestante'],
            'dum' => $params['gestante'] ? ($params['dum'] ?? null) : null,
        ];
    }

    private function prepareMedicamentosUsoData(array $params, AtendimentoMedico $atendimentoMedico) : ?array
    {
        if (!isset($params['medicamentos_uso'])) {

            return null;
        }

        return [
            'atendimento_medico_id' => $atendimentoMedico->id,
            'descricao' => $params['medicamentos_uso'],
        ];
    }

    private function prepareSinaisVitaisData(array $params, AtendimentoMedico $atendimentoMedico) : array
    {
        $sinaisVitaisData = [];

        foreach (($params['sinais_vitais'] ?? []) as $sinaisVitais) {

            $sinaisVitaisData[] = [
                'atendimento_medico_id' => $atendimentoMedico->id,
                'pa' => $sinaisVitais['pa'] ?? null,
                'pa_unidade_medida_id' => isset($sinaisVitais['pa'])
                    ? $sinaisVitais['pa_unidade_medida_id']
                    : null,
                'glicemia' => $sinaisVitais['glicemia'] ?? null,
                'temperatura' => $sinaisVitais['temperatura'] ?? null,
                'pulso' => $sinaisVitais['pulso'] ?? null,
                'respiracao' => $sinaisVitais['respiracao'] ?? null,
                'saturacao' => $sinaisVitais['saturacao'] ?? null,
                'intensidade_dor' => $sinaisVitais['intensidade_dor'] ?? null,
                'cintura' => $sinaisVitais['cintura'] ?? null,
            ];
        }

        return $sinaisVitaisData;
    }

    private function prepareAvaliacaoAntropometricaData(array $params, AtendimentoMedico $atendimentoMedico) : ?array
    {
        if (!isset($params['avaliacao_antropometrica'])) {

            return null;
        }

        $params = $params['avaliacao_antropometrica'];

        return [
            'atendimento_medico_id' => $atendimentoMedico->id,
            'massa' => $params['massa'] ?? null,
            'massa_unidade_medida_id' => isset($params['massa'])
                ? $params['massa_unidade_medida_id']
                : null,
            'altura' => $params['altura'] ?? null,
            'altura_unidade_medida_id' => isset($params['altura'])
                ? $params['altura_unidade_medida_id']
                : null,
            'altura_tipo_medida_id' => isset($params['altura'])
                ? $params['altura_tipo_medida_id']
                : null,
        ];
    }

    private function prepareObservacaoData(array $params, AtendimentoMedico $atendimentoMedico) : ?array
    {
        if (!isset($params['observacoes'])) {

            return null;
        }

        return [
            'atendimento_medico_id' => $atendimentoMedico->id,
            'descricao' => $params['observacoes'],
        ];
    }

    private function handleDorToracica(array $params, AtendimentoMedico $atendimentoMedico)
    {
        $formulario = FormularioDorToracica::where('atendimento_id', $atendimentoMedico->atendimento->id)->get();

        foreach ($formulario as $registro) {

            $formularioId = $registro->id;
        }

        if (!isset($formularioId)) {

            return;
        }

        $formulario = $formulario->where('id', $formularioId)->first();

        $formulario->update([
            'protocolo_finalizado' => $params['dor_toracica_protocolo_finalizado'],
            'protocolo_finalizado_em' => !$params['dor_toracica_protocolo_finalizado']
                ? null
                : ($formulario->dor_toracica_protocolo_finalizado ? $formulario->protocolo_finalizado_em : Carbon::now()),
            'protocolo_tem_prosseguimento' => $params['dor_toracica_protocolo_tem_prosseguimento'],
            'tem_contra_indicacao_trombolitico' => $params['dor_toracica_protocolo_tem_prosseguimento']
                ? $params['dor_toracica_tem_contra_indicacao_trombolitico']
                : null,
            'contra_indicacao_trombolitico_motivo' => $params['dor_toracica_protocolo_tem_prosseguimento']
                && $params['dor_toracica_tem_contra_indicacao_trombolitico']
                ? $params['dor_toracica_contra_indicacao_trombolitico_motivo']
                : null,
        ]);

        if (isset($params['dor_toracica_resultado_eletrocardiograma'])) {

            FormularioDorToracicaResultadoEletrocardiograma::create([
                'formulario_dor_toracica_id' => $formularioId,
                'atendimento_medico_id' => $atendimentoMedico->id,
                'descricao' => $params['dor_toracica_resultado_eletrocardiograma'],
            ]);
        }

        $formulario->sinaisInstabilidade()->sync($params['dor_toracica_protocolo_tem_prosseguimento']
            ? $params['dor_toracica_sinais_instabilidade']
            : []
        );
    }

    private function prepareDoencasCronicasData(array $params) : ?array
    {
        if (!isset($params['doencas_cronicas'])) {

            return null;
        }

        return [
            'descricao' => $params['doencas_cronicas'],
        ];
    }

    private function prepareAtestadoData(array $params) : ?array
    {
        if (!isset($params['atestado'])) {

            return null;
        }

        $params = $params['atestado'];

        return [
            'modelo_id' => $params['modelo_id'] ?? AtestadoModelo::PADRAO,
            'nome_acompanhante' => $params['nome_acompanhante'],
            'paciente' => $params['paciente'],
            'imprime_cid' => $params['imprime_cid'],
            'dias' => $params['dias'] ?? null,
            'quantidade_horas' => $params['quantidade_horas'] ?? null,
            'horario_inicial' => $params['horario_inicial'] ?? null,
            'documento_tipo_id' => $params['documento_tipo_id'],
            'documento_numero' => $params['documento_numero'],
        ];
    }

    private function prepareEncaminhamentosData(array $params) : array
    {
        $encaminhamentos = [];

        foreach (($params['encaminhamentos'] ?? []) as $encaminhamento) {

            $encaminhamentos[] = [
                'urgente' => $encaminhamento['urgente'],
                'ocupacao_id' => $encaminhamento['ocupacao_id'],
                'motivo' => $encaminhamento['motivo'],
                'observacoes' => $encaminhamento['observacoes'] ?? null,
            ];
        }

        return $encaminhamentos;
    }

    private function prepareDeclaracoesComparecimentoData(array $params) : array
    {
        $declaracoesComparecimento = [];

        foreach (($params['declaracoes_comparecimento'] ?? []) as $declaracao) {

            $item = [
                'tipo_id' => $declaracao['tipo_id'],
                'documento_tipo_id' => $declaracao['documento_tipo_id'],
                'documento_numero' => $declaracao['documento_numero'],
                'de' => $declaracao['de'],
                'ate' => $declaracao['ate'],
                'motivo' => $declaracao['motivo'],
            ];

            if ($declaracao['tipo_id'] === DeclaracaoComparecimentoTipo::ACOMPANHANTE) {

                $item['nome'] = $declaracao['nome'];
            }

            $declaracoesComparecimento[] = $item;
        }

        return $declaracoesComparecimento;
    }

    private function prepareReceitaMedicaData($params)
    {
        if (is_null($params['receita_medica'] ?? null)
            || (empty($params['receita_medica']['medicamentos'])
                && empty($params['receitas_medicas_assinadas'])
            )
        ) {

            return [];
        }

        $receitaMedica = [
            'is_assinada' => $params['receita_medica']['is_assinada'],
            'medicamentos' => [],
        ];

        foreach ($params['receita_medica']['medicamentos'] as $medicamento) {

            $viaAdministracaoId = null;

            if (!is_null($medicamento['medicamento_id'])) {
                $viaAdministracaoId = Medicamento::findOrFail($medicamento['medicamento_id'])
                    ->via_administracao_id;
            }

            $item = [
                'prescricao_manual' => $medicamento['prescricao_manual'],
                'medicamento_id' => $medicamento['medicamento_id'],
                'medicamento_manual' => $medicamento['medicamento_manual'],
            ];

            if ($viaAdministracaoId === EnumViaAdministracao::OUTRAS) {

                $item['via_administracao_outras'] = $medicamento['via_administracao_outras'];
            }

            $usoContinuo = $medicamento['tipo_aplicacao'] === 'uso_continuo';
            $livre = $medicamento['tipo_aplicacao'] === 'livre';
            $padrao = $medicamento['tipo_aplicacao'] === 'padrao';

            if ($padrao || $usoContinuo) {

                if (($medicamento['v'] ?? null) === TipoPosologia::FREQUENCIA) {

                    $item['intervalo_tempo'] = $medicamento['intervalo_tempo'];
                    $item['intervalo_medida_tempo_id'] = $medicamento['intervalo_medida_tempo_id'];
                }
                else if (($medicamento['tipo_posologia'] ?? null) === TipoPosologia::TURNO) {

                    $item['turno_id'] = $medicamento['turno_id'];
                }
            }

            if ($padrao) {

                $item['durante_tempo'] = $medicamento['durante_tempo'];
                $item['durante_medida_tempo_id'] = $medicamento['durante_medida_tempo_id'];
            }

            if ($livre) {

                $item['descricao'] = $medicamento['descricao'];
            }
            else {

                $item['quantidade'] = $medicamento['quantidade'];
                $item['recomendacoes'] = $medicamento['recomendacoes'] ?? null;
            }

            $receitaMedica['medicamentos'][] = $item;
        }

        return $receitaMedica;
    }

    private function preparePrescricoesInternasData(array $params) : array
    {
        $prescricoesInternas = [];

        foreach (($params['prescricoes_internas'] ?? []) as $prescricao) {

            $prescricaoInterna = [
                'observacoes' => $prescricao['observacoes'],
                'medicamentos' => [],
            ];

            if (!$prescricao['dose_unica']) {

                $prescricaoInterna['frequencia_quantidade_vezes'] = $prescricao['frequencia_quantidade_vezes'];
                $prescricaoInterna['frequencia_tempo'] = $prescricao['frequencia_tempo'];
                $prescricaoInterna['frequencia_medida_tempo_id'] = $prescricao['frequencia_medida_tempo_id'];
            }

            foreach ($prescricao['medicamentos'] as $medicamento) {

                $prescricaoInterna['medicamentos'][] = [
                    'medicamento_id' => $medicamento['medicamento_id'],
                    'unidade_medida_id' => $medicamento['unidade_medida_id'],
                    'quantidade' => $medicamento['quantidade'],
                    'administracao' => $medicamento['administracao'],
                ];
            }

            $prescricoesInternas[] = $prescricaoInterna;
        }

        return $prescricoesInternas;
    }

    private function prepareRaatData(array $params, AtendimentoMedico $atendimentoMedico) : ?array
    {
        if (!isset($params['raat'])) {

            return null;
        }

        if (!$atendimentoMedico->atendimento->faa->isRaatAberta) {

            return null;
        }

        $params = $params['raat'];

        $raat = [
            'id' => $params['id'],
            'atendimento_medico_id' => $atendimentoMedico->id,
            'agente_id' => $params['agente_id'],
            'partes_corpo_atingidas' => $params['partes_corpo_atingidas'],
            'causas_acidente' => $params['causas_acidente'],
            'diagnosticos' => $params['diagnosticos'],
            'observacao' => $params['observacao'] ?? null,
            'classificacao_inicial_id' => $params['classificacao_inicial_id'],
            'afastado' => $params['afastado'],
            'acidente_tipo_id' => $params['acidente_tipo_id']
        ];

        if (in_array(ParteCorpoAtingida::OUTROS, $raat['partes_corpo_atingidas'])) {

            $raat['parte_corpo_atingida_outras'] = $params['parte_corpo_atingida_outras'];
        }

        if (in_array(CausaAcidente::OUTROS, $raat['causas_acidente'])) {

            $raat['causa_acidente_outras'] = $params['causa_acidente_outras'];
        }

        if (in_array(Diagnostico::OUTROS, $raat['diagnosticos'])) {

            $raat['diagnostico_outros'] = $params['diagnostico_outros'];
        }

        return $raat;
    }

    private function prepareProcedimentosData($params, $atendimentoMedico, $isReavaliacao)
    {
        $procedimentos = [];

        foreach (($params['procedimentos'] ?? []) as $procedimento) {

            $procedimentos[] = [
                'lotacao_id' => auth()->payload()->get('lotacao_id'),
                'atendimento_medico_id' => $atendimentoMedico->id,
                'procedimento_id' => $procedimento['procedimento_id'],
                'cid_principal_id' => $procedimento['cid_principal_id'] ?? null,
                'cid_secundario_id' => isset($procedimento['cid_principal_id'])
                    ? $procedimento['cid_secundario_id'] ?? null
                    : null,
                'quantidade' => $procedimento['quantidade'],
            ];
        }

        if (!$isReavaliacao) {

            $procedimentoParametrizado = $this->getProcedimentoParametrizado();

            if ($procedimentoParametrizado) {

                $procedimentos[] = [
                    'lotacao_id' => auth()->payload()->get('lotacao_id'),
                    'atendimento_medico_id' => $atendimentoMedico->id,
                    'procedimento_id' => $procedimentoParametrizado['procedimento']['id'],
                    'cid_principal_id' => $params['cid_id'] ?? null,
                    'quantidade' => 1,
                    'is_parametrizado' => true,
                ];
            }
        }

        if (!is_null($atendimentoMedico->avaliacaoAntropometrica)) {

            $this->addProcedimentoAvaliacaoAntropometricaData($procedimentos, $atendimentoMedico);
        }

        $sinaisVitais = $atendimentoMedico->sinaisVitais()->get();

        if ($sinaisVitais->isNotEmpty()) {

            $this->addProcedimentosSinaisVitaisData($sinaisVitais, $procedimentos, $atendimentoMedico->id);
        }

        return $procedimentos;
    }

    private function preparePedidoExameData(array $params, Atendimento $atendimento) : ?array
    {
        if (!isset($params['pedidos_exames'])) {

            return null;
        }

        $pedidoExame = $params['pedidos_exames'];

        $result = [
            'atendimento_id' => $atendimento->id,
            'urgente' => $pedidoExame['urgente'],
            'justificativa' => $pedidoExame['justificativa'],
            'exames' => [],
        ];

        foreach ($pedidoExame['exames'] as $exame) {

            $valor = Exame::findOrFail($exame['exame_id']);

            $result['exames'][] = [
                'exame_id' => $exame['exame_id'],
                'valor_exame' => $valor->valor ?? null,
                'observacao' => $exame['observacao'] ?? null,
            ];
        }

        return $result;
    }

    private function storePedido($pedidoExame, $atendimentoMedico)
    {
        $pedido = $atendimentoMedico->pedidosExames()->create($pedidoExame);

        foreach ($pedidoExame['exames'] as $item) {

            $createdItem = $pedido->exames()->create($item);

            if (!empty($item['observacao'])) {

                $createdItem->observacoes()->create([
                    'observacao' => $item['observacao']
                ]);
            }
        }
    }

    private function addProcedimentoAvaliacaoAntropometricaData(&$procedimentos, $atendimentoMedico)
    {
        $proc = Procedimento::where('codigo', ProcedimentoEnum::AVALIACAO_ANTROPOMETRICA)
            ->orderByDesc('competencia_id')
            ->firstOrFail();

        $validation = new ProcedimentoValidationService($proc);

        if ($validation->isOcupacaoValid($this->getCurrentLotacao()->ocupacao)) {

            if (!$atendimentoMedico->atendimento->procedimentos->contains('procedimento_id', $proc->id)) {

                if (collect($procedimentos)->contains('procedimento_id', $proc->id)) {

                    foreach ($procedimentos as $i => $procedimento) {

                        if ($procedimento['procedimento_id'] === $proc->id) {

                            $procedimentos[$i]['quantidade']++;

                            break;
                        }
                    }
                }
                else {

                    $procedimentos[] = [
                        'lotacao_id' => auth()->payload()->get('lotacao_id'),
                        'atendimento_medico_id' => $atendimentoMedico->id,
                        'procedimento_id' => $proc->id,
                        'quantidade' => 1,
                    ];
                }
            }
        }
    }

    private function addProcedimentosSinaisVitaisData($sinaisVitais, &$procedimentos, int $atendimentoMedicoId)
    {
        $quantidadeMedicoesPa = 0;
        $quantidadeMedicoesGlicemia = 0;

        foreach ($sinaisVitais as $sinaisVitaisItem) {

            if (!is_null($sinaisVitaisItem->pa)) {

                $quantidadeMedicoesPa++;
            }

            if (!is_null($sinaisVitaisItem->glicemia)) {

                $quantidadeMedicoesGlicemia++;
            }
        }

        if ($quantidadeMedicoesPa > 0) {

            $this->addProcedimentoPaData($quantidadeMedicoesPa, $procedimentos, $atendimentoMedicoId);
        }

        if ($quantidadeMedicoesGlicemia > 0) {

            $this->addProcedimentoGlicemiaData($quantidadeMedicoesGlicemia, $procedimentos, $atendimentoMedicoId);
        }
    }

    private function addProcedimentoPaData($quantidade, &$procedimentos, int $atendimentoMedicoId)
    {
        $proc = Procedimento::where('codigo', ProcedimentoEnum::AFERICAO_PRESSAO_ARTERIAL)
            ->orderByDesc('competencia_id')
            ->firstOrFail();

        $validation = new ProcedimentoValidationService($proc);

        if ($validation->isOcupacaoValid($this->getCurrentLotacao()->ocupacao)) {

            if (collect($procedimentos)->contains('procedimento_id', $proc->id)) {

                foreach ($procedimentos as $i => $procedimento) {

                    if ($procedimento['procedimento_id'] === $proc->id) {

                        $procedimentos[$i]['quantidade'] += $quantidade;

                        break;
                    }
                }
            }
            else {

                $procedimentos[] = [
                    'lotacao_id' => auth()->payload()->get('lotacao_id'),
                    'atendimento_medico_id' => $atendimentoMedicoId,
                    'procedimento_id' => $proc->id,
                    'quantidade' => $quantidade,
                ];
            }
        }
    }

    private function addProcedimentoGlicemiaData($quantidade, &$procedimentos, int $atendimentoMedicoId)
    {
        $proc = Procedimento::where('codigo', ProcedimentoEnum::GLICEMIA_CAPILAR)
            ->orderByDesc('competencia_id')
            ->firstOrFail();

        $validation = new ProcedimentoValidationService($proc);

        if ($validation->isOcupacaoValid($this->getCurrentLotacao()->ocupacao)) {

            if (collect($procedimentos)->contains('procedimento_id', $proc->id)) {

                foreach ($procedimentos as $i => $procedimento) {

                    if ($procedimento['procedimento_id'] === $proc->id) {

                        $procedimentos[$i]['quantidade'] += $quantidade;

                        break;
                    }
                }
            }
            else {

                $procedimentos[] = [
                    'lotacao_id' => auth()->payload()->get('lotacao_id'),
                    'atendimento_medico_id' => $atendimentoMedicoId,
                    'procedimento_id' => $proc->id,
                    'quantidade' => $quantidade,
                ];
            }
        }
    }

    private function getCentroCustoLogado()
    {
        return CentroCusto::findOrFail(auth()->payload()->get('centro_custo_id'));
    }

    private function getDadosForm($atendimento, $centroCustoLogado)
    {
        $lotacao = $this->getLotacaoLogado();
        $parametrizacao = ParametrizacaoAtendimentoMedicoService::get($centroCustoLogado->infraestrutura_id);

        $atendimentoCids = $atendimento->cids()
            ->groupBy('cid_id')
            ->with('cid')
            ->orderBy('created_at')
            ->get()
            ->makeHidden(['atendimento_id', 'atendimento_medico_id', 'cid_id']);

        $cids = [];

        foreach ($atendimentoCids as $value) {
            $cids[] = [
                'id' => $value->id ?? null,
                'cid' => $value->cid,
                'lotacao' => [
                    'ocupacao' => [
                        'id' => $value->createdLotacao->ocupacao->id ?? null,
                        'codigo' => $value->createdLotacao->ocupacao->codigo ?? null,
                        'nome' => $value->createdLotacao->ocupacao->nome ?? null,
                    ],
                    'profissional' => [
                        'nome' => $value->createdLotacao->usuario->cidadao->nome ?? null,
                    ],
                ],
                'centro_custo' => [
                    'setor' => [
                        'nome' => $value->createdCentroCusto->setor->nome ?? null,
                    ],
                ],
                'classificacao_risco' => [
                    'nome' => $value->atendimentoMedico->classificacaoRisco->classificacaoRisco->nome ?? null,
                ],
                'data_hora' => $value->created_at->format('d/m/Y H:i:s') ?? null,
            ];
        }

        $encaminhamentos = [];

        foreach ($atendimento->atendimentosMedico as $atendimentoMedico) {
            foreach ($atendimentoMedico->encaminhamentos as $encaminhamento) {
                $encaminhamentos[] = [
                    'id' => $encaminhamento->id ?? null,
                    'lotacao' => [
                        'ocupacao' => [
                            'codigo' => $encaminhamento->createdLotacao->ocupacao->codigo ?? null,
                        ],
                        'profissional' => [
                            'nome' => $encaminhamento->createdLotacao->usuario->cidadao->nome ?? null,
                        ],
                    ],
                    'ocupacao' => [
                        'id' => $encaminhamento->ocupacao->id ?? null,
                        'nome' => $encaminhamento->ocupacao->nome ?? null,
                    ],
                    'urgente' => $encaminhamento->urgente ?? false,
                    'motivo' => $encaminhamento->motivo ?? null,
                    'observacoes' => $encaminhamento->observacoes ?? null,
                ];
            }
        }

        $declaracoesComparecimento = [];

        foreach ($atendimento->atendimentosMedico as $atendimentoMedico) {
            foreach ($atendimentoMedico->declaracoesComparecimento as $declaracaoComparecimento) {
                $nome = $declaracaoComparecimento->tipo_id === DeclaracaoComparecimentoTipo::PACIENTE
                    ? $declaracaoComparecimento->atendimentoMedico->atendimento->faa->paciente->cidadao->nome
                    : $declaracaoComparecimento->nome;

                $declaracoesComparecimento[] = [
                    'id' => $declaracaoComparecimento->id,
                    'lotacao' => [
                        'ocupacao' => [
                            'id' => $declaracaoComparecimento->createdLotacao->ocupacao->id ?? null,
                            'codigo' => $declaracaoComparecimento->createdLotacao->ocupacao->codigo ?? null,
                            'nome' => $declaracaoComparecimento->createdLotacao->ocupacao->nome ?? null,
                        ],
                        'profissional' => [
                            'nome' => $declaracaoComparecimento->createdLotacao->usuario->cidadao->nome ?? null,
                        ],
                    ],
                    'centro_custo' => [
                        'setor' => [
                            'nome' => $declaracaoComparecimento->createdCentroCusto->setor->nome ?? null,
                        ],
                    ],
                    'classificacao_risco' => [
                        'nome' => $declaracaoComparecimento->atendimentoMedico->classificacaoRisco->classificacaoRisco->nome ?? null,
                    ],
                    'data_hora' => $declaracaoComparecimento->created_at->format('d/m/Y H:i:s') ?? null,
                    'tipo_id' => $declaracaoComparecimento->tipo_id ?? null,
                    'nome' => $nome ?? null,
                    'documento_numero' => $declaracaoComparecimento->documento_numero ?? null,
                    'documento_tipo_id' => $declaracaoComparecimento->documento_tipo_id ?? null,
                    'data_de' => $declaracaoComparecimento->de->format('d/m/Y') ?? null,
                    'hora_de' => $declaracaoComparecimento->de->format('H:i:s') ?? null,
                    'data_ate' => $declaracaoComparecimento->ate->format('d/m/Y') ?? null,
                    'hora_ate' => $declaracaoComparecimento->ate->format('H:i:s') ?? null,
                    'motivo' => $declaracaoComparecimento->motivo ?? null,
                ];
            }
        }

        $prescricoesInternas = [];

        foreach ($atendimento->atendimentosMedico as $atendimentoMedico) {
            foreach ($atendimentoMedico->prescricoesInternas as $prescricaoInterna) {
                $prescricoesInternas[] = [
                    'id' => $prescricaoInterna->id ?? null,
                    'frequencia_quantidade_vezes' => $prescricaoInterna->frequencia_quantidade_vezes ?? null,
                    'frequencia_tempo' => $prescricaoInterna->frequencia_tempo ?? null,
                    'frequencia_medida_tempo_id' => $prescricaoInterna->frequencia_medida_tempo_id ?? null,
                    'observacoes' => $prescricaoInterna->observacoes ?? null,
                    'medicamentos' => $prescricaoInterna->medicamentos->map(function($medicamento) {
                        return [
                            'id' => $medicamento->id ?? null,
                            'medicamento' => $medicamento->medicamento ?? null,
                            'quantidade' => $medicamento->quantidade ?? null,
                            'unidade_medida_id' => $medicamento->unidadeMedida->id ?? null,
                            'unidade_medida_sigla' => $medicamento->unidadeMedida->sigla ?? null,
                            'forma_farmaceutica_nome' => $medicamento->medicamento->formaFarmaceutica->nome ?? null,
                            'administracao' => $medicamento->administracao ?? null,
                            'aplicacoes' => $medicamento->aplicacoes->map(fn ($aplicacao) => [
                                'id' => $aplicacao->id,
                                'status' => [
                                    'id' => $aplicacao->status->id,
                                    'nome' => $aplicacao->status->nome,
                                ],
                                'profissional' => [
                                    'nome' => $aplicacao->updatedLotacao->usuario->cidadao->nome,
                                ],
                                'horario_aplicacao' => $aplicacao->horario_aplicacao,
                            ])
                        ];
                    }),
                    'dose_unica' => $prescricaoInterna->dose_unica ?? false,
                    'lotacao' => [
                        'ocupacao' => [
                            'id' => $prescricaoInterna->createdLotacao->ocupacao->id ?? null,
                            'codigo' => $prescricaoInterna->createdLotacao->ocupacao->codigo ?? null,
                            'nome' => $prescricaoInterna->createdLotacao->ocupacao->nome ?? null,
                        ],
                        'profissional' => [
                            'nome' => $prescricaoInterna->createdLotacao->usuario->cidadao->nome ?? null,
                        ],
                    ],
                    'centro_custo' => [
                        'setor' => [
                            'nome' => $prescricaoInterna->createdCentroCusto->setor->nome ?? null,
                        ],
                    ],
                    'classificacao_risco' => [
                        'nome' => $prescricaoInterna->atendimentoMedico->classificacaoRisco->classificacaoRisco->nome ?? null,
                    ],
                    'data_hora' => $prescricaoInterna->created_at->format('d/m/Y H:i:s') ?? null,
                    'collapse' => true,
                ];
            }
        }

        $atestados = [];

        foreach ($atendimento->faa->paciente->faas as $pacienteFaa) {
            foreach ($pacienteFaa->atendimentos->first()->atendimentosMedico as $atendimentoMedico) {
                if ($atendimentoMedico->atestado) {
                    $atestados[] = [
                        'data' => new Carbon($atendimentoMedico->atestado->created_at),
                        'unidade' => [
                            'nome_fantasia' => $atendimentoMedico->atestado->createdLotacao->infraestrutura->unidade->nome_fantasia ?? null,
                        ],
                        'profissional' => [
                            'nome' => $atendimentoMedico->atestado->createdLotacao->usuario->cidadao->nome ?? null
                        ]
                    ];
                }
            }
        }

        $cboLogado = Lotacao::findOrFail(auth()->payload()->get('lotacao_id'))->ocupacao->codigo;

        $encaminhamentoSetores = [];

        if ($atendimento->fila->centroCusto->setor->tipo_id === SetorTipo::OBSERVACAO) {
            $encaminhamentoSetores = Encaminhamento::where('centro_custo_id_de', $atendimento->fila->centro_custo_id)
                ->whereDoesntHave('centroCustoPara.setor', fn ($q) => $q->where('tipo_id', SetorTipo::OBSERVACAO));
        } else {
            $encaminhamentoSetores = Encaminhamento::where('centro_custo_id_de', auth()->payload()->get('centro_custo_id'));
        }

        $exibeHistoricoErpsaude = app('config')->get('database.default') == 'santarita' ? true : false;

        return [
            'data_atual' => Carbon::now()->format('d/m/Y'),
            'data_max_proxima_reavaliacao' => Carbon::now()->addDay()->format('d/m/Y'),
            'tipo_atendimento_id' => $parametrizacao->tipo_id,
            'classificacoes_risco' => ClassificacaoRisco::all()->map(function($query) {
                return [
                    'id' => $query->id,
                    'nome' => $query->nome,
                    'cor' => $query->tipo->cor,
                    'cor_nome' => $query->tipo->cor_nome,
                ];
            }),
            'atendimento_triagem' => [
                'procedimentos' => $this->getProcedimentos($atendimento, Carbon::now(), 'triagem'),
                'outras_avaliacoes_condicoes' => AtendimentoTriagem::where('atendimento_id', $atendimento->id)
                    ->whereNotNull('outras_avaliacoes_condicoes')
                    ->orderBy('created_at')
                    ->get()
                    ->map(function ($avaliacao) {

                        return [
                            'descricao' => $avaliacao->outras_avaliacoes_condicoes,
                            'lotacao' => [
                                'ocupacao' => [
                                    'id' => $avaliacao->createdLotacao->ocupacao->id ?? null,
                                    'codigo' => $avaliacao->createdLotacao->ocupacao->codigo ?? null,
                                    'nome' => $avaliacao->createdLotacao->ocupacao->nome ?? null,
                                ],
                                'profissional' => [
                                    'nome' => $avaliacao->createdLotacao->usuario->cidadao->nome ?? null,
                                ],
                            ],
                            'centro_custo' => [
                                'setor' => [
                                    'nome' => $avaliacao->createdCentroCusto->setor->nome ?? null,
                                ],
                            ],
                            'classificacao_risco' => [
                                'nome' => $avaliacao->classificacaoRisco->classificacaoRisco->nome ?? null,
                            ],
                            'data_hora' => $avaliacao->created_at->format('d/m/Y H:i:s'),
                        ];
                })
            ],
            'atendimento_enfermagem' => [
                'historicos' => $this->getAreaAtendimentoEnfermagemByKey($atendimento, 'historico'),
                'diagnosticos' => $this->getAreaAtendimentoEnfermagemByKey($atendimento, 'diagnostico'),
                'planejamentos' => $this->getAreaAtendimentoEnfermagemByKey($atendimento, 'planejamento'),
                'implementacoes' => $this->getAreaAtendimentoEnfermagemByKey($atendimento, 'implementacao'),
                'avaliacoes' => $this->getAreaAtendimentoEnfermagemByKey($atendimento, 'avaliacao'),
                'procedimentos' => $this->getProcedimentos($atendimento, Carbon::now(), 'enfermagem'),
                'anotacoes' => $this->getAnotacoes($atendimento, Carbon::now()),
            ],
            'atendimento_exame_imagem' => [
                'procedimentos' => $this->getProcedimentos($atendimento, Carbon::now(), 'exame_imagem'),
            ],
            'traumas' => $this->getTraumas(),
            'unidades_medida' => UnidadeMedida::orderBy('sigla')->get(),
            'raat' => RaatService::getOptionsParecerMedico(),
            'encaminhamentos' => $encaminhamentos,
            'encaminhamento_especialidades' => Ocupacao::whereIn('id', EncaminhamentoEspecialidade::all()
                ->pluck('ocupacao_id'))
                ->orderBy('nome')
                ->get(),
            'prescricao_medica' => ReceitaTipo::all(),
            'vias_administracao' => ViaAdministracao::all(),
            'formas_farmaceutica' => FormaFarmaceutica::all(),
            'unidades_medida_tempo' => MedidaTempo::all(),
            'unidades_medida' => UnidadeMedida::all(),
            'unidades_medida_medicamento' =>  UnidadeMedida::where('id', '<>', UnidadeMedidaEnum::NIVEL_DE_DOR)
                ->where('id', '<>', UnidadeMedidaEnum::BATIMENTOS_POR_MINUTO)
                ->where('id', '<>', UnidadeMedidaEnum::CELSIUS)
                ->get()
                ->map(fn ($unidadesMedidas) => [
                    'id' => $unidadesMedidas->id,
                    'nome' => $unidadesMedidas->nome,
                    'sigla' => $unidadesMedidas->sigla,
                ]),
            'documentos_tipo' => DocumentoTipo::all(),
            'paciente' => [
                'id' => $atendimento->faa->paciente->id,
                'nome' => $atendimento->faa->paciente->cidadao->nome,
                'nome_social' => $atendimento->faa->paciente->cidadao->nome_social,
                'preferencia_nome_id' => $atendimento->faa->paciente->cidadao->preferencia_nome_id,
                'prontuario' => $atendimento->faa->paciente->prontuario,
                'cpf' => $atendimento->faa->paciente->cidadao->cpf,
                'cns' => $atendimento->faa->paciente->cidadao->cns,
                'data_nascimento' => $atendimento->faa->paciente->cidadao->data_nascimento,
                'idade' => $atendimento->faa->paciente->cidadao->idade,
                'is_desconhecido' => $atendimento->faa->paciente->is_desconhecido,
                'caracteristicas_fisicas' => $atendimento->faa->paciente->cidadao->caracteristicas_fisicas,
                'sexo' => $atendimento->faa->paciente->cidadao->sexo,
                'pcd' => $this->getPcd($atendimento->faa->paciente->cidadao),
            ],
            'recepcao' => [
                'motivo_atendimento' => $atendimento->recepcao->motivo_atendimento ?? null,
                'acompanhante' => $atendimento->recepcao->acompanhante,
                'atendido_em' => $atendimento->recepcao->atendido_em,
                'data_de' => $atendimento->recepcao->atendido_em,
                'hora_de' => Carbon::parse($atendimento->recepcao->atendido_em)->format('H:i')
            ],
            'alergia_criticidades' => AlergiaCriticidade::all()->map(function($query) {
                return [
                    'id' => $query->id,
                    'nome' => $query->nome,
                ];
            }),
            'alergia_tipos' => AlergiaTipo::all()->map(function($query) {
                return [
                    'id' => $query->id,
                    'descricao' => $query->descricao,
                ];
            }),
            'encaminhamento_setores' => $encaminhamentoSetores
                ->get()
                ->map(function($query) {
                    return [
                        'id' => $query->centroCustoPara->id ?? null,
                        'nome' => $query->centroCustoPara->setor->nome ?? null,
                        'tipo' => [
                            'id' => $query->centroCustoPara->setor->tipo_id ?? null
                        ],
                    ];
                })->values(),
            'lotacao' => [
                'ocupacao' => [
                    'codigo' => $lotacao->ocupacao->codigo,
                    'nome' => $lotacao->ocupacao->nome,
                ],
                'profissional' => [
                    'id' => $lotacao->usuario->id,
                    'nome' => $lotacao->usuario->cidadao->nome,
                ],
            ],
            'medicamentos_uso' => $this->getMedicamentosUso($atendimento, Carbon::now()),
            'unidades' => Unidade::orderBy('nome_fantasia')->get(),
            'kits' => KitExame::orderBy('nome')
                ->get()
                ->map(fn ($kit) => [
                    'id' => $kit->id,
                    'nome' => $kit->nome,
                    'checked' => false,
                    'exames' => DB::table('parametrizacao_kit_exame_item')
                        ->join(
                            'parametrizacao_exame',
                            'parametrizacao_exame.id',
                            'parametrizacao_kit_exame_item.exame_id'
                        )
                        ->join('sigtap.procedimento', function ($join) {

                            $join->on('sigtap.procedimento.codigo', 'parametrizacao_exame.codigo')
                                ->where('sigtap.procedimento.competencia_id', '=', function ($query) {

                                    $query->select('sigtap.competencia.id')
                                        ->from('sigtap.competencia')
                                        ->orderByDesc('sigtap.competencia.valor')
                                        ->limit(1);
                                });
                        })
                        ->whereNull('parametrizacao_kit_exame_item.deleted_at')
                        ->where('parametrizacao_kit_exame_item.kit_exame_id', $kit->id)
                        ->when($kit->tipo_id === Tipo::IMAGEM, function ($query) use ($cboLogado) {

                            $query->whereExists(function($query) use ($cboLogado) {

                                $query->select(DB::raw(1))
                                    ->from('sigtap.procedimento_ocupacao')
                                    ->whereColumn('sigtap.procedimento_ocupacao.procedimento_id', 'sigtap.procedimento.id')
                                    ->join('sigtap.ocupacao', 'sigtap.ocupacao.id', 'sigtap.procedimento_ocupacao.ocupacao_id')
                                    ->where('sigtap.ocupacao.codigo', $cboLogado);
                            })->orWhereNotExists(function($query) {

                                $query->select(DB::raw(1))
                                    ->from('sigtap.procedimento_ocupacao')
                                    ->whereColumn('sigtap.procedimento_ocupacao.procedimento_id', 'sigtap.procedimento.id');
                            });
                        })
                        ->when($kit->tipo_id === Tipo::LABORATORIAL, function ($query) {

                            $query->where(fn ($q) => $q
                                ->whereExists(fn ($q) => $q
                                    ->selectRaw(1)
                                    ->from('exame_laboratorial_parametrizacao_unidade_solicitante_exame_item')
                                    ->join(
                                        'exame_laboratorial_parametrizacao_unidade_solicitante_exame',
                                        'exame_laboratorial_parametrizacao_unidade_solicitante_exame.id',
                                        'exame_laboratorial_parametrizacao_unidade_solicitante_exame_item.unidade_solicitante_exame_id'
                                    )
                                    ->whereColumn(
                                        'exame_laboratorial_parametrizacao_unidade_solicitante_exame_item.exame_id',
                                        'parametrizacao_exame.id'
                                    )
                                    ->where(
                                        'exame_laboratorial_parametrizacao_unidade_solicitante_exame.infraestrutura_id',
                                        self::getCentroCustoLogado()->infraestrutura_id
                                    )
                                )
                                ->orWhereNotExists(fn ($q) => $q
                                    ->selectRaw(1)
                                    ->from('exame_laboratorial_parametrizacao_unidade_solicitante_exame')
                                    ->where(
                                        'exame_laboratorial_parametrizacao_unidade_solicitante_exame.infraestrutura_id',
                                        self::getCentroCustoLogado()->infraestrutura_id
                                    )
                                )
                            );
                        })
                        ->orderBy('parametrizacao_exame.nome')
                        ->select(
                            'parametrizacao_exame.id',
                            'parametrizacao_exame.codigo',
                            'parametrizacao_exame.nome',
                            'parametrizacao_exame.tipo_id'
                        )
                        ->get()
                        ->map(fn  ($exame) => [
                            'id' => $exame->id,
                            'codigo' => $exame->codigo,
                            'nome' => $exame->nome,
                            'tipo_id' => $exame->tipo_id,
                            'checked' => false,
                        ])
                        ->values()
                ])
                ->filter(fn ($kit) => count($kit['exames']) > 0)
                ->values(),
            'procedimentos' => $this->getProcedimentos($atendimento, Carbon::now()),
            'servicos_enfermagem' => $this->getServicosEnfermagem($atendimento),
            'cids' => $cids,
            'reavaliacao' => $atendimento->atendimentosMedico()->get()->isNotEmpty(),
            'pedidos_exames' => $this->getPedidoExame($atendimento),
            'prescricoes_internas' => $prescricoesInternas,
            'atestados' => $atestados,
            'sinais_vitais' => $this->getSinaisVitais($atendimento, Carbon::now()),
            'evolucao' => $atendimento->atendimentosMedico->whereNotNull('evolucao')
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'classificacao_risco' => [
                            'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->evolucao,
                    ];
                })
                ->values(),
            'atendimento_geral' => $atendimento->atendimentosMedico->whereNotNull('atendimento_geral')
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'classificacao_risco' => [
                            'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->atendimento_geral,
                    ];
                })
                ->values(),
            'queixa_principal_duracao' => $atendimento->atendimentosMedico->whereNotNull('queixa_principal_duracao')
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'classificacao_risco' => [
                            'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->queixa_principal_duracao,
                    ];
                })
                ->values(),
            'historia' => $atendimento->atendimentosMedico->whereNotNull('historia')
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'classificacao_risco' => [
                            'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->historia,
                    ];
                })
                ->values(),
            'exame_fisico' => $atendimento->atendimentosMedico->whereNotNull('exame_fisico')
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'classificacao_risco' => [
                            'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->exame_fisico,
                    ];
                })
                ->values(),
            'diagnostico' => $atendimento->atendimentosMedico->whereNotNull('diagnostico')
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'classificacao_risco' => [
                            'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->diagnostico,
                    ];
                })
                ->values(),
            'conduta' => $atendimento->atendimentosMedico->whereNotNull('conduta')
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'classificacao_risco' => [
                            'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->conduta,
                    ];
                })
                ->values(),
            'observacoes_enfermagem' => $atendimento->atendimentosMedico->whereNotNull('observacoes_enfermagem')
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'classificacao_risco' => [
                            'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->observacoes_enfermagem,
                    ];
                })
                ->values(),
            'observacoes' => $atendimento->observacoes
                ->map(function($query) {
                    return [
                        'centro_custo' => [
                            'setor' => [
                                'nome' => $query->createdCentroCusto->setor->nome ?? null,
                            ],
                        ],
                        'lotacao' => [
                            'ocupacao' => [
                                'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                            ],
                            'profissional' => [
                                'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                            ],
                        ],
                        'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                        'descricao' => $query->descricao,
                    ];
                })
                ->values(),
            'declaracoes_comparecimento' => $declaracoesComparecimento,
            'historico_atendimento' => $this->getHistoricoAtendimento($atendimento),
            'fatores_risco' => $this->getFatoresRisco($atendimento),
            'fatores_risco_gestante' => $this->getFatoresRiscoGestante($atendimento),
            'paciente_observacao' => $this->getPacienteObservacaoData($atendimento),
            'turnos' => Turno::orderBy('nome')
                ->get()
                ->map(function ($turno) {

                    return [
                        'id' => $turno->id,
                        'nome' => $turno->nome
                    ];
                }),
            'escalas_coma_glasgow' => $this->getEscalasComaGlasgow($atendimento),
            'glasgow' => [
                'aberturas_ocular' => $this->getGlasgowAberturaOcular(),
                'reatividades_Pupilar' => $this->getGlasgowReatividadePupilar(),
                'respostas_motora' => $this->getGlasgowRespostaMotora(),
                'respostas_verbal' => $this->getGlasgowRespostaVerbal(),
            ],
            'formulario_dor_toracica' => [
                'dor_toracica_data_sintoma' => null,
                'dor_toracica_hora_ecg_admissao' => null,
                'hora_sintoma' => null,
                'hora_ecg_admissao' => null,
                'dispneia' => null,
                'caracteristica_dor' => $this->getCaracteristicaDor(),
                'localizacao_dor' => $this->getLocalizacaoDor(),
                'fator_desencadeante' => $this->getFatorDesencadeante(),
                'fatores_risco_toracica' => $this->getFatoresRiscoToracica(),
                'duracao_dor' => $this->getDuracaoDor(),
                'sugestoes_medicacoes' => [
                    ['nome' => 'Ácido Acetil Salicílico'],
                    ['nome' => 'Alteplase'],
                    ['nome' => 'Clopidrogel'],
                ],
                'sinais_instabilidade' => DorToracicaSinalInstabilidade::orderBy('nome')->get(['id', 'nome']),
            ],
            'desfechos' => ModelDesfecho::get(),
            'prioridades' => Prioridade::orderBy('nome')
                ->get()
                ->map(fn ($prioridade) => [
                    'id' => $prioridade->id,
                    'nome' => $prioridade->nome,
                ]),
            'prioridade_id' => $atendimento->fila->prioridade_id,
            'historico' => AmbulatorioAtendimentoService::getHistorico($atendimento->faa->paciente->id),
            'historico_erpsaude' => $exibeHistoricoErpsaude ? AmbulatorioAtendimentoService::getHistoricoErpsaude($atendimento->faa->paciente) : null,
            'exibe_historico_erpsaude' => $exibeHistoricoErpsaude,
        ];
    }

    private function getAnotacoes($atendimento, $datetime)
    {
        return Anotacao::where('created_at', '<=', $datetime)
            ->whereHas('atendimentoEnfermagem', function ($query) use ($atendimento) {

                $query->where('atendimento_id', $atendimento->id);
            })
            ->get()
            ->map(function ($anotacao) {
                return array_merge(
                    $this->getBaseHistoricoAreaAtendimento($anotacao->atendimentoEnfermagem, $anotacao->atendimentoEnfermagem->atendimento),
                    [
                        'id' => $anotacao->id,
                        'data_hora_anotacao' => $anotacao->anotado_em->format('Y-m-d H:i'),
                        'anotacao' => $anotacao->descricao,
                    ]
                );
            })
            ->sortBy('created_at');
    }

    private function getBaseHistoricoAreaAtendimento($model, $atendimento)
    {
        $result = [
            'centro_custo' => [
                'setor' => [
                    'nome' => $model->createdCentroCusto->setor->nome,
                ],
            ],
            'lotacao' => [
                'ocupacao' => [
                    'codigo' => $model->createdLotacao->ocupacao->codigo,
                    'nome' => $model->createdLotacao->ocupacao->nome,
                ],
                'profissional' => [
                    'nome' => $model->createdLotacao->usuario->cidadao->nome,
                ],
            ],
            'classificacao_risco' => [
                'nome' => $this->getClassificacaoRisco($atendimento, $model->created_at)['nome'] ?? null
            ],
            'data_hora' => $model->created_at->format('d/m/Y H:i:s'),
        ];

        return $result;
    }

    private function getClassificacaoRisco($atendimento, $datetime)
    {
        $classificacaoRisco = $atendimento->classificacoesRisco()
            ->where('created_at', '<=', $datetime)
            ->get()
            ->sortByDesc('created_at')
            ->first();

        if ($classificacaoRisco == null)
            return null;

        return [
            'id' => $classificacaoRisco->id,
            'classificacao_risco_id' => $classificacaoRisco->classificacao_risco_id,
            'nome' => $classificacaoRisco->classificacaoRisco->nome,
        ];
    }

    private function getAreaAtendimentoEnfermagemByKey($atendimento, $key)
    {
        switch($key) {

            case 'historico': {

                return Historico::where('atendimento_id', $atendimento->id)
                    ->orderBy('created_at')
                    ->get()
                    ->map(function ($historico) use ($atendimento) {

                        return [
                            'descricao' => $historico->descricao,
                            'lotacao' => [
                                'ocupacao' => [
                                    'id' => $historico->createdLotacao->ocupacao->id ?? null,
                                    'codigo' => $historico->createdLotacao->ocupacao->codigo ?? null,
                                    'nome' => $historico->createdLotacao->ocupacao->nome ?? null,
                                ],
                                'profissional' => [
                                    'nome' => $historico->createdLotacao->usuario->cidadao->nome ?? null,
                                ],
                            ],
                            'centro_custo' => [
                                'setor' => [
                                    'nome' => $historico->createdCentroCusto->setor->nome ?? null,
                                ],
                            ],
                            'classificacao_risco' => [
                                'nome' => $this->getClassificacaoRisco($atendimento, $historico->created_at)['nome'] ?? null,
                            ],
                            'data_hora' => $historico->created_at->format('d/m/Y H:i:s'),
                        ];
                    });
            }

            case 'diagnostico': {

                return DiagnosticoEnfermagem::where('atendimento_id', $atendimento->id)
                    ->orderBy('created_at')
                    ->get()
                    ->map(function ($diagnostico) use ($atendimento) {

                        return [
                            'descricao' => $diagnostico->descricao,
                            'lotacao' => [
                                'ocupacao' => [
                                    'id' => $diagnostico->createdLotacao->ocupacao->id ?? null,
                                    'codigo' => $diagnostico->createdLotacao->ocupacao->codigo ?? null,
                                    'nome' => $diagnostico->createdLotacao->ocupacao->nome ?? null,
                                ],
                                'profissional' => [
                                    'nome' => $diagnostico->createdLotacao->usuario->cidadao->nome ?? null,
                                ],
                            ],
                            'centro_custo' => [
                                'setor' => [
                                    'nome' => $diagnostico->createdCentroCusto->setor->nome ?? null,
                                ],
                            ],
                            'classificacao_risco' => [
                                'nome' => $this->getClassificacaoRisco($atendimento, $diagnostico->created_at)['nome'] ?? null,
                            ],
                            'data_hora' => $diagnostico->created_at->format('d/m/Y H:i:s'),
                        ];
                    });
            }

            case 'planejamento': {

                return Planejamento::where('atendimento_id', $atendimento->id)
                    ->orderBy('created_at')
                    ->get()
                    ->map(function ($planejamento) use ($atendimento) {

                        return [
                            'descricao' => $planejamento->descricao,
                            'lotacao' => [
                                'ocupacao' => [
                                    'id' => $planejamento->createdLotacao->ocupacao->id ?? null,
                                    'codigo' => $planejamento->createdLotacao->ocupacao->codigo ?? null,
                                    'nome' => $planejamento->createdLotacao->ocupacao->nome ?? null,
                                ],
                                'profissional' => [
                                    'nome' => $planejamento->createdLotacao->usuario->cidadao->nome ?? null,
                                ],
                            ],
                            'centro_custo' => [
                                'setor' => [
                                    'nome' => $planejamento->createdCentroCusto->setor->nome ?? null,
                                ],
                            ],
                            'classificacao_risco' => [
                                'nome' => $this->getClassificacaoRisco($atendimento, $planejamento->created_at)['nome'] ?? null,
                            ],
                            'data_hora' => $planejamento->created_at->format('d/m/Y H:i:s'),
                        ];
                    });
            }

            case 'implementacao': {

                return Implementacao::where('atendimento_id', $atendimento->id)
                    ->orderBy('created_at')
                    ->get()
                    ->map(function ($implementacao) use ($atendimento) {

                        return [
                            'descricao' => $implementacao->descricao,
                            'lotacao' => [
                                'ocupacao' => [
                                    'id' => $implementacao->createdLotacao->ocupacao->id ?? null,
                                    'codigo' => $implementacao->createdLotacao->ocupacao->codigo ?? null,
                                    'nome' => $implementacao->createdLotacao->ocupacao->nome ?? null,
                                ],
                                'profissional' => [
                                    'nome' => $implementacao->createdLotacao->usuario->cidadao->nome ?? null,
                                ],
                            ],
                            'centro_custo' => [
                                'setor' => [
                                    'nome' => $implementacao->createdCentroCusto->setor->nome ?? null,
                                ],
                            ],
                            'classificacao_risco' => [
                                'nome' => $this->getClassificacaoRisco($atendimento, $implementacao->created_at)['nome'] ?? null,
                            ],
                            'data_hora' => $implementacao->created_at->format('d/m/Y H:i:s'),
                        ];
                    });
            }

            case 'avaliacao': {

                return Avaliacao::where('atendimento_id', $atendimento->id)
                    ->orderBy('created_at')
                    ->get()
                    ->map(function ($avaliacao) use ($atendimento) {

                        return [
                            'descricao' => $avaliacao->descricao,
                            'lotacao' => [
                                'ocupacao' => [
                                    'id' => $avaliacao->createdLotacao->ocupacao->id ?? null,
                                    'codigo' => $avaliacao->createdLotacao->ocupacao->codigo ?? null,
                                    'nome' => $avaliacao->createdLotacao->ocupacao->nome ?? null,
                                ],
                                'profissional' => [
                                    'nome' => $avaliacao->createdLotacao->usuario->cidadao->nome ?? null,
                                ],
                            ],
                            'centro_custo' => [
                                'setor' => [
                                    'nome' => $avaliacao->createdCentroCusto->setor->nome ?? null,
                                ],
                            ],
                            'classificacao_risco' => [
                                'nome' => $this->getClassificacaoRisco($atendimento, $avaliacao->created_at)['nome'] ?? null,
                            ],
                            'data_hora' => $avaliacao->created_at->format('d/m/Y H:i:s'),
                        ];
                    });
            }
        }
    }

    private function getTraumas()
    {
        return PacienteTraumaStatus::all()
            ->map(function ($pacienteTrauma) {

                return [
                    'id' => $pacienteTrauma->id,
                    'nome' => $pacienteTrauma->nome,
                ];
            });
    }

    private function getAlergias($atendimento, $datetime)
    {
        $alergias = $atendimento->faa->paciente->cidadao->alergias()->wherePivot('created_at', '<=', $datetime)->get();
        $result = [];

        foreach ($alergias as $i => $alergia) {
            $result[] = [
                'index' => $i,
                'alergia' => [
                    'agente_substancia_especifica' => $alergia->agente_substancia_especifica,
                    'criticidade' => [
                        'id' => $alergia->cidadaoAlergia->criticidade->id,
                        'nome' => $alergia->cidadaoAlergia->criticidade->nome,
                    ],
                    'id' => $alergia->cidadaoAlergia->alergia_id,
                    'reacoes_observacoes' => $alergia->cidadaoAlergia->reacoes_observacoes,
                    'tipo' => [
                        'id' => $alergia->tipo->id,
                        'descricao' => $alergia->tipo->descricao,
                    ]
                ],
                'lotacao' => [
                    'ocupacao' => [
                        'id' => $alergia->cidadaoAlergia->createdLotacao->ocupacao->id ?? null,
                        'codigo' => $alergia->cidadaoAlergia->createdLotacao->ocupacao->codigo ?? null,
                        'nome' => $alergia->cidadaoAlergia->createdLotacao->ocupacao->nome ?? null,
                    ],
                    'profissional' => [
                        'nome' => $alergia->cidadaoAlergia->createdLotacao->usuario->cidadao->nome ?? null,
                    ],
                ],
                'centro_custo' => [
                    'setor' => [
                        'nome' => $alergia->cidadaoAlergia->createdCentroCusto->setor->nome ?? null,
                    ],
                ],
                'data_hora' => $alergia->cidadaoAlergia->created_at->format('d/m/Y H:i:s') ?? null,
            ];
        }

        return $result;
    }

    private function getMedicamentosUsoContinuo($atendimento, $datetime)
    {
        $medicamentos = $atendimento->faa->paciente->cidadao->medicamentosUsoContinuo()->wherePivot('created_at', '<=', $datetime)->get();
        $result = [];

        foreach ($medicamentos as $medicamento) {
            $result[] = [
                'medicamento' => [
                    'nome' => $medicamento->nome,
                    'id' => $medicamento->CidadaoMedicamentoUsoContinuo->medicamento_id,
                ],
                'lotacao' => [
                    'ocupacao' => [
                        'id' => $medicamento->CidadaoMedicamentoUsoContinuo->createdLotacao->ocupacao->id ?? null,
                        'codigo' => $medicamento->CidadaoMedicamentoUsoContinuo->createdLotacao->ocupacao->codigo ?? null,
                        'nome' => $medicamento->CidadaoMedicamentoUsoContinuo->createdLotacao->ocupacao->nome ?? null,
                    ],
                    'profissional' => [
                        'nome' => $medicamento->CidadaoMedicamentoUsoContinuo->createdLotacao->usuario->cidadao->nome ?? null,
                    ],
                ],
                'centro_custo' => [
                    'setor' => [
                        'nome' => $medicamento->CidadaoMedicamentoUsoContinuo->createdCentroCusto->setor->nome ?? null,
                    ],
                ],
                'data_hora' => $medicamento->CidadaoMedicamentoUsoContinuo->created_at->format('d/m/Y H:i:s') ?? null,
            ];
        }

        return $result;
    }

    private function getCidadaoFatoresRisco($atendimento)
    {
        $cidadao = $atendimento->faa->paciente->cidadao;
        $fatoresRisco = $cidadao->fatoresRisco;
        $result = [];

        foreach ($fatoresRisco as $fatorRisco) {
            $result[] = $fatorRisco->cidadaoFatorRisco->fator_risco_id;
        }

        return $result;
    }

    private function getMedicamentosUso($atendimento, $datetime)
    {
        return $atendimento->medicamentosUso->where('created_at', '<=', $datetime)
            ->map(function($query) {
                return [
                    'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                    'centro_custo' => [
                        'setor' => [
                            'nome' => $query->createdCentroCusto->setor->nome ?? null,
                        ],
                    ],
                    'descricao' => $query->descricao,
                    'lotacao' => [
                        'ocupacao' => [
                            'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                        ],
                        'profissional' => [
                            'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                        ],
                    ],
                ];
            })->values();
    }

    private function getHistoricoAtendimento($atendimento)
    {
        $historicoAtendimento = Atendimento::whereHas('faa', function($query) use ($atendimento) {
                $query->where('paciente_id', $atendimento->faa->paciente_id);
            })
            ->where('id', '<>', $atendimento->id)
            ->orderBy('created_at', 'desc')
            ->take(10)
            ->get();

        return $historicoAtendimento->map(function($value) {
            $atendimento = $value->faa->atendimentos->sortByDesc('created_at')->first();
            $atendimentoClassificacaoRisco = $atendimento->classificacoesRisco->sortByDesc('created_at')->first();
            $atendimentoCid = $atendimento->cids->sortByDesc('created_at')->first();
            $receitas = collect([]);

            $hasAtendimento = $atendimento
                ->where(function ($query) {

                    $query->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 = !is_null($procedimentoPadrao)
                    ? $procedimentoPadrao->lotacao
                    : $atendimento->createdLotacao ?? null;

            } else {

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

                $atendimento->atendimentosMedico->map(function($atendimentoMedico) use ($receitas) {

                    if (!is_null($atendimentoMedico->receita ?? null)) {

                        if ($atendimentoMedico->receita->medicamentos->isNotEmpty()) {

                            $receitas->push($atendimentoMedico->receita);
                        }
                    }
                });

                $lotacaoProfissionalResponsavel = !is_null($firstAtendimentoMedico)
                    ? $firstAtendimentoMedico->createdLotacao
                    : $atendimento->createdLotacao ?? null;
            }

            $params = [
                'paciente' => [
                    'id' => $value->faa->paciente_id,
                ],
                'atendido_em' => Carbon::create($value->recepcao->atendido_em)->format('d/m/Y H:i:s') ?? null,
                'cid' => [
                    'codigo' => $atendimentoCid->cid->codigo ?? $procedimentoPadrao->cidPrincipal->codigo ?? null,
                    'nome' => $atendimentoCid->cid->nome ?? $procedimentoPadrao->cidPrincipal->nome ?? null,
                ],
                'classificacao_risco' => [
                    'cor' => $atendimentoClassificacaoRisco->classificacaoRisco->tipo->cor ?? "#FFFFFF",
                    'nome' => $atendimentoClassificacaoRisco->classificacaoRisco->nome ?? null,
                ],
                'id' => $atendimento->id ?? null,
                'lotacao' => [
                    'ocupacao' => [
                        'nome' => $lotacaoProfissionalResponsavel->ocupacao->nome ?? null,
                    ],
                    'profissional' => [
                        'nome' => $lotacaoProfissionalResponsavel->usuario->cidadao->nome ?? null,
                    ],
                ],
                'unidade' => [
                    'nome' => $atendimento->createdLotacao->infraestrutura->unidade->nome_fantasia ?? null,
                ],
                'receitas' => $receitas,
                'desfecho' => [
                    'nome' => $atendimento->faa->desfecho->nome ?? null,
                ],
            ];

            return $params;
        });
    }

    private static function getFatoresRisco()
    {
        $result = FatorRisco::orderBy('id')
            ->whereIn('id', [
                FatorRiscoEnum::CANCERO,
                FatorRiscoEnum::DIABETES,
                FatorRiscoEnum::ETILISMO,
                FatorRiscoEnum::HIPERTENSAO,
                FatorRiscoEnum::OBESIDADE,
                FatorRiscoEnum::PERFIL_SANGUINEO_ALTERADO,
                FatorRiscoEnum::RADIOTERAPIA,
                FatorRiscoEnum::TABAGISMO,
                FatorRiscoEnum::USO_DE_MEDICAMENTOS_ANTINEOPLASICOS_OU_IMUNOSSUPRESSORES,
                FatorRiscoEnum::OUTRO,
            ])
            ->get()
                ->map(fn ($fatorRisco) => [
                'id' => $fatorRisco->id,
                'nome' => $fatorRisco->nome,
            ]);

        return $result;
    }

    private static function getFatoresRiscoGestante()
    {
        $result = FatorRisco::orderBy('nome')
            ->whereIn('id', [
                FatorRiscoEnum::CANCERO,
                FatorRiscoEnum::DIABETES,
                FatorRiscoEnum::ETILISMO,
                FatorRiscoEnum::HIPERTENSAO,
                FatorRiscoEnum::OBESIDADE,
                FatorRiscoEnum::PERFIL_SANGUINEO_ALTERADO,
                FatorRiscoEnum::RADIOTERAPIA,
                FatorRiscoEnum::TABAGISMO,
                FatorRiscoEnum::USO_DE_MEDICAMENTOS_ANTINEOPLASICOS_OU_IMUNOSSUPRESSORES,
                FatorRiscoEnum::OUTRO,
                FatorRiscoEnum::GESTANTE,
            ])
            ->get()
            ->map(fn ($fatorRisco) => [
                'id' => $fatorRisco->id,
                'nome' => $fatorRisco->nome,
            ]);

        return $result;
    }

    private function getPacienteObservacaoData($atendimento)
    {
        $pacienteObservacoes = $atendimento->pacienteObservacoes()->orderBy('created_at')->get();
        $firstPacienteObservacao = $pacienteObservacoes->first();
        $lastPacienteObservacao = $pacienteObservacoes->last();

        if (is_null($firstPacienteObservacao)) {

            return null;
        }

        $entradaObservacao = $firstPacienteObservacao->created_at->format('d/m/Y H:i:s');
        $lastAtendimentoMedico = $atendimento->atendimentosMedico()->orderBy('created_at')->get()->last();

        $dataHoraProximaReavaliacao = null;

        if (!is_null($lastAtendimentoMedico->data_hora_proxima_reavaliacao ?? null)) {

            $dataHoraProximaReavaliacao = $lastAtendimentoMedico->data_hora_proxima_reavaliacao->format('d/m/Y H:i');
        }

        return [
            'entrada_observacao' => $entradaObservacao,
            'tempo_em_observacao' => $this->getTempoEmObservacao($atendimento),
            'paciente_atingiu24horas' => $this->pacienteAtingiu24HorasObservacao($atendimento),
            'quarto' => $lastPacienteObservacao->quarto,
            'leito' => $lastPacienteObservacao->leito,
            'data_hora_proxima_reavaliacao' => $dataHoraProximaReavaliacao,
            'hemorragia_externa_grave' => [
                'id' => $lastPacienteObservacao->hemorragiaExternaGrave->id ?? null,
                'nome' => $lastPacienteObservacao->hemorragiaExternaGrave->nome ?? null,
            ],
            'hemorragia_externa_grave_local' => $lastPacienteObservacao->hemorragia_externa_grave_local ?? null,
            'vias_aerias' => [
                'id' => $lastPacienteObservacao->viasAerias->id ?? null,
                'nome' => $lastPacienteObservacao->viasAerias->nome ?? null,
            ],
            'vias_aerias_obstrucao_por' => $lastPacienteObservacao->vias_aerias_obstrucao_por ?? null,
            'oxigenacao_respiracao_ventilacao' => [
                'id' => $lastPacienteObservacao->oxigenacaoRespiracaoVentilacao->id ?? null,
                'nome' => $lastPacienteObservacao->oxigenacaoRespiracaoVentilacao->nome ?? null,
            ],
            'pulso' => [
                'id' => $lastPacienteObservacao->pulso->id ?? null,
                'nome' => $lastPacienteObservacao->pulso->nome ?? null,
            ],
            'pele' => [
                'id' => $lastPacienteObservacao->pele->id ?? null,
                'nome' => $lastPacienteObservacao->pele->nome ?? null,
            ],
            'pele_alteracao' => $lastPacienteObservacao->pele_alteracao ?? null,
            'perfusao' => [
                'id' => $lastPacienteObservacao->perfuracao->id ?? null,
                'nome' => $lastPacienteObservacao->perfuracao->nome ?? null,
            ],
            'perfusao_lentificada' => $lastPacienteObservacao->perfuracao_lentificada ?? null,
            'sangramento' => [
                'id' => $lastPacienteObservacao->sangramento->id ?? null,
                'nome' => $lastPacienteObservacao->sangramento->nome ?? null,
            ],
            'sangramento_local' => $lastPacienteObservacao->sangramento_local ?? null,
            'pupilas' => [
                'id' => $lastPacienteObservacao->pupilas->id ?? null,
                'nome' => $lastPacienteObservacao->pupilas->nome ?? null,
            ],
            'paresias' => [
                'id' => $lastPacienteObservacao->paresias->id ?? null,
                'nome' => $lastPacienteObservacao->paresias->nome ?? null,
            ],
            'plegia' => [
                'id' => $lastPacienteObservacao->plegia->id ?? null,
                'nome' => $lastPacienteObservacao->plegia->nome ?? null,
            ],
            'exposicao_hipotermia' => [
                'id' => $lastPacienteObservacao->exposicaoHipotermia->id ?? null,
                'nome' => $lastPacienteObservacao->exposicaoHipotermia->nome ?? null,
            ],
            'exposicao_hipotermia_observacao' => $lastPacienteObservacao->exposicao_hipotermia_observacao ?? null,
            'avaliacao_cabeca_pescoco' => $this->getAvaliacaoCabecaPescoco($lastPacienteObservacao),
            'avaliacao_torax' => $lastPacienteObservacao->avaliacao_torax ?? null,
            'avaliacao_abdome' => $lastPacienteObservacao->avaliacao_abdome ?? null,
            'avaliacao_mmss_mmii' => $lastPacienteObservacao->avaliacao_mmss_mmii ?? null,
            'observacao' => $lastPacienteObservacao->observacao ?? null,
            'procedimentos' => $this->getProcedimentos($atendimento, Carbon::now(), 'observacao'),
        ];
    }

    private function getAvaliacaoCabecaPescoco($pacienteObservacao)
    {
        if (is_null($pacienteObservacao)) {

            return null;
        }

        return [
            'avaliacao_cabeca_pescoco' => $pacienteObservacao->avaliacao_cabeca_pescoco ?? null,
            'lotacao' => [
                'ocupacao' => [
                    'id' => $pacienteObservacao->createdLotacao->ocupacao->id ?? null,
                    'codigo' => $pacienteObservacao->createdLotacao->ocupacao->codigo ?? null,
                    'nome' => $pacienteObservacao->createdLotacao->ocupacao->nome ?? null,
                ],
                'profissional' => [
                    'nome' => $pacienteObservacao->createdLotacao->usuario->cidadao->nome ?? null,
                ],
            ],
            'centro_custo' => [
                'setor' => [
                    'nome' => $pacienteObservacao->createdCentroCusto->setor->nome ?? null,
                ],
            ],
            'classificacao_risco' => [
                'nome' => $pacienteObservacao->classificacaoRisco->classificacaoRisco->nome ?? null,
            ],
            'data_hora' => $pacienteObservacao->created_at->format('d/m/Y H:i:s'),
        ];
    }

    private function getTempoEmObservacao($atendimento)
    {
        $firstPacienteObservacao = $atendimento->pacienteObservacoes
            ? $atendimento->pacienteObservacoes()->orderBy('created_at')->first()
            : null;

        if (is_null($firstPacienteObservacao)) {

            return '00:00:00';
        }

        $diff = $firstPacienteObservacao->created_at->diff(Carbon::now());

        $msg = $diff->format('%H:%I:%S');

        if ($diff->d >= 1) {

            $createdAtPacienteObservacao = new Carbon($firstPacienteObservacao->created_at);
            $timeReach24Hours = $createdAtPacienteObservacao->modify('+24 hours');

            $msg = $timeReach24Hours->format('H:i:s');
        }

        return $msg;
    }

    private function pacienteAtingiu24HorasObservacao($atendimento)
    {
        $firstPacienteObservacao = $atendimento->pacienteObservacoes
            ? $atendimento->pacienteObservacoes()->orderBy('created_at')->first()
            : null;

        if (is_null($firstPacienteObservacao)) {

            return false;
        }

        $diff = $firstPacienteObservacao->created_at->diff(Carbon::now());

        return $diff->d >= 1;
    }

    private function getSinaisVitais($atendimento, $datetime)
    {
        $sinaisVitais = $atendimento->sinaisVitais()->where('created_at', '<=', $datetime)->get();
        $result = [];

        foreach ($sinaisVitais as $sinalVital) {

            $result[] = [
                'id' => $sinalVital->id,
                'pa' => $sinalVital->pa,
                'pa_unidade_medida_id' => $sinalVital->pa_unidade_medida_id,
                'glicemia' => $sinalVital->glicemia,
                'glicemia_unidade_medida_id' => UnidadeMedidaEnum::MILIGRAMAS_POR_DECILITRO,
                'temperatura' => $sinalVital->temperatura,
                'temperatura_unidade_medida_id' => UnidadeMedidaEnum::CELSIUS,
                'pulso' => $sinalVital->pulso,
                'pulso_unidade_medida_id' => UnidadeMedidaEnum::BATIMENTOS_POR_MINUTO,
                'respiracao' => $sinalVital->respiracao,
                'respiracao_unidade_medida_id' => UnidadeMedidaEnum::MOVIMENTOS_POR_MINUTO,
                'saturacao' => $sinalVital->saturacao,
                'saturacao_unidade_medida_id' => UnidadeMedidaEnum::PORCENTAGEM,
                'intensidade_dor' => $sinalVital->intensidade_dor,
                'intensidade_dor_unidade_medida_id' => UnidadeMedidaEnum::NIVEL_DE_DOR,
                'cintura' => $sinalVital->cintura,
                'cintura_unidade_medida_id' => UnidadeMedidaEnum::CENTIMETROS,
                'lotacao' => [
                    'ocupacao' => [
                        'id' => $sinalVital->createdLotacao->ocupacao->id ?? null,
                        'codigo' => $sinalVital->createdLotacao->ocupacao->codigo ?? null,
                        'nome' => $sinalVital->createdLotacao->ocupacao->nome ?? null,
                    ],
                    'profissional' => [
                        'nome' => $sinalVital->createdLotacao->usuario->cidadao->nome ?? null,
                    ],
                ],
                'centro_custo' => [
                    'setor' => [
                        'nome' => $sinalVital->createdCentroCusto->setor->nome ?? null,
                    ],
                ],
                'classificacao_risco' => [
                    'nome' => (
                        $sinalVital->atendimentoMedico
                        ?? $sinalVital->atendimentoTriagem
                        ?? $sinalVital->atendimentoEnfermagem
                        ?? $sinalVital->pacienteObservacao
                    )->classificacaoRisco->classificacaoRisco->nome ?? null,
                ],
                'data_hora' => $sinalVital->created_at->format('d/m/Y H:i:s'),
            ];
        }

        return $result;
    }

    private function getAvaliacaoAntropometrica($avaliacaoAntropometrica)
    {
        return [
            'massa' => $avaliacaoAntropometrica->massa ?? null,
            'massa_unidade_medida_id' => $avaliacaoAntropometrica->massa_unidade_medida_id ?? UnidadeMedidaEnum::QUILOGRAMAS,
            'massa_unidade_medida' => [
                'nome' => $avaliacaoAntropometrica->massaUnidadeMedida->nome ?? null,
                'sigla' => $avaliacaoAntropometrica->massaUnidadeMedida->sigla ?? null,
            ],
            'altura_tipo_medida_id' => $avaliacaoAntropometrica->altura_tipo_medida_id ?? TipoMedidaAlturaEnum::ESTATURA,
            'altura' => $avaliacaoAntropometrica->altura ?? null,
            'altura_tipo_medida' => [
                'nome' => $avaliacaoAntropometrica->alturaTipoMedida->nome ?? null,
            ],
            'altura_unidade_medida_id' => $avaliacaoAntropometrica->altura_unidade_medida_id ?? UnidadeMedidaEnum::METROS,
            'altura_unidade_medida' => [
                'nome' => $avaliacaoAntropometrica->alturaUnidadeMedida->nome ?? null,
                'sigla' => $avaliacaoAntropometrica->alturaUnidadeMedida->sigla ?? null,
            ],
            'imc' => [
                'imc' => $avaliacaoAntropometrica->imc['imc'] ?? null,
                'classificacao' => $avaliacaoAntropometrica->imc['classificacao'] ?? null,
            ],
        ];
    }

    private function getPcd($cidadao)
    {
        if ($cidadao->deficiencia_id === null) {

            return null;
        }

        $deficiencia = [
            'id' => $cidadao->deficiencia->id,
            'deficiencia_base_id' => $cidadao->deficiencia->deficiencia_base_id,
            'descricao' => $cidadao->deficiencia->descricao
        ];

        if ($cidadao->deficiencia->deficiencia_base_id === Deficiencia::OUTRA) {

            $deficiencia['deficiencia_outro'] = $cidadao->deficiencia_outro;

            return $deficiencia;
        }

        return $deficiencia;
    }

    private function getProcedimentos($atendimento, $datetime, $origem = 'medico')
    {
        $procedimentos = $atendimento->procedimentos()
            ->with('procedimento', 'cidPrincipal')
            ->where('created_at', '<=', $datetime);

        if ($origem === 'medico') {

            $procedimentos->whereNotNull('atendimento_medico_id');
        }
        else if ($origem === 'triagem') {

            $procedimentos->whereNotNull('atendimento_triagem_id');
        }
        else if ($origem === 'enfermagem') {

            $procedimentos->whereNotNull('atendimento_enfermagem_id');
        }
        else if ($origem === 'exame_imagem') {

            $procedimentos->whereNotNull('exame_imagem_id');
        }
        else if ($origem === 'observacao') {

            $procedimentos->whereNotNull('paciente_observacao_id');
        }

        $procedimentos = $procedimentos->orderBy('created_at')->get();

        $result = [];

        foreach ($procedimentos as $procedimento) {

            $result[] = [
                'id' => $procedimento->id ?? null,
                'lotacao' => [
                    'ocupacao' => [
                        'id' => $procedimento->createdLotacao->ocupacao->id ?? null,
                        'codigo' => $procedimento->createdLotacao->ocupacao->codigo ?? null,
                        'nome' => $procedimento->createdLotacao->ocupacao->nome ?? null,
                    ],
                    'profissional' => [
                        'nome' => $procedimento->createdLotacao->usuario->cidadao->nome ?? null,
                    ],
                ],
                'procedimento' => $procedimento->procedimento,
                'cid_principal' => $procedimento->cidPrincipal ?? null,
                'quantidade' => $procedimento->quantidade ?? null,
                'centro_custo' => [
                    'setor' => [
                        'nome' => $procedimento->createdCentroCusto->setor->nome ?? null,
                    ],
                ],
                'classificacao_risco' => [
                    'nome' => ($procedimento->atendimentoMedico
                            ?? $procedimento->atendimentoTriagem
                            ?? $procedimento->atendimentoEnfermagem
                            ?? $procedimento->pacienteObservacao
                        )->classificacaoRisco->classificacaoRisco->nome ?? null,
                ],
                'data_hora' => $procedimento->created_at->format('d/m/Y H:i:s'),
            ];
        }

        if ($origem === 'medico') {

            $isReavaliacao = $atendimento->atendimentosMedico()->get()->isNotEmpty();

            if (!$isReavaliacao) {

                $procedimentoParametrizado = $this->getProcedimentoParametrizado();

                if ($procedimentoParametrizado) {

                    $result[] = $procedimentoParametrizado;
                }
            }
        }

        return $result;
    }

    private function getProcedimentoParametrizado()
    {
        $centroCustoLogado = $this->getCentroCustoLogado();
        $lotacao = $this->getLotacaoLogado();
        $procedimentoParametrizado = ParametrizacaoAtendimentoMedico::first()->procedimento_padrao ?? null;

        if (is_null($procedimentoParametrizado)) {

            return null;
        }

        return [
            'id' => null,
            'lotacao' => [
                'ocupacao' => [
                    'id' => $lotacao->ocupacao->id ?? null,
                    'codigo' => $lotacao->ocupacao->codigo ?? null,
                    'nome' => $lotacao->ocupacao->nome ?? null,
                ],
                'profissional' => [
                    'nome' => $lotacao->usuario->cidadao->nome ?? null,
                ],
            ],
            'procedimento' => [
                'id' => $procedimentoParametrizado->id,
                'codigo' => $procedimentoParametrizado->codigo ?? null,
                'nome' => $procedimentoParametrizado->nome ?? null,
                'is_parametrizado' => true,
            ],
            'cid_principal' => [
                'id' => null,
                'codigo' => null,
                'nome' => null,
            ],
            'cid_secundario' => [
                'id' => null,
                'codigo' => null,
                'nome' => null,
            ],
            'quantidade' => 1,
            'centro_custo' => [
                'setor' => [
                    'nome' => $centroCustoLogado->setor->nome ?? null,
                ],
            ],
            'classificacao_risco' => [
                'nome' => null,
            ],
            'data_hora' => null,
        ];
    }

    private function getServicosEnfermagem($atendimento)
    {
        $result = [];

        ServicoEnfermagem::where(function ($query) use ($atendimento) {

            $query
                ->whereHas('atendimentoMedico', function ($query) use ($atendimento) {

                    $query->where('atendimento_id', $atendimento->id);
                })
                ->orWhereHas('atendimentoEnfermagem', function ($query) use ($atendimento) {

                    $query->where('atendimento_id', $atendimento->id);
                });
        })->each(function ($servicoEnfermagem) use (&$result) {

            $result[] = [
                'id' => $servicoEnfermagem->id ?? null,
                'status' => [
                    'id' => $servicoEnfermagem->status_id,
                    'nome' => $servicoEnfermagem->status->nome,
                ],
                'lotacao' => [
                    'ocupacao' => [
                        'id' => $servicoEnfermagem->createdLotacao->ocupacao->id ?? null,
                        'codigo' => $servicoEnfermagem->createdLotacao->ocupacao->codigo ?? null,
                        'nome' => $servicoEnfermagem->createdLotacao->ocupacao->nome ?? null,
                    ],
                    'profissional' => [
                        'nome' => $servicoEnfermagem->createdLotacao->usuario->cidadao->nome ?? null,
                    ],
                ],
                'procedimento' => $servicoEnfermagem->procedimento,
                'centro_custo' => [
                    'setor' => [
                        'nome' => $servicoEnfermagem->createdCentroCusto->setor->nome ?? null,
                    ],
                ],
                'classificacao_risco' => [
                    'nome' => ($servicoEnfermagem->atendimentoMedico->classificacaoRisco
                        ?? $servicoEnfermagem->atendimentoEnfermagem->classificacaoRisco
                    )->classificacaoRisco->nome ?? null,
                ],
                'data_hora' => $servicoEnfermagem->created_at->format('d/m/Y H:i:s'),
                'observacoes' => $servicoEnfermagem->observacoes,
            ];
        });

        return $result;
    }

    private function getPedidoExame($atendimento)
    {
        $lotacaoLogado = $this->getLotacaoLogado();

        $pedidosExames = [];

        foreach ($atendimento->atendimentosMedico as $atendimentoMedico) {
            foreach ($atendimentoMedico->pedidosExames as $pedidoExame) {
                $pedido = [
                    'id' => $pedidoExame->id ?? null,
                    'urgente' => $pedidoExame->urgente ?? null,
                    'justificativa' => $pedidoExame->justificativa ?? null,
                    'data_solicitacao' => $pedidoExame->data_solicitacao
                        ? $pedidoExame->data_solicitacao->format('d/m/Y')
                        : $pedidoExame->created_at->format('d/m/Y H:i'),
                    'lotacao' => [
                        'ocupacao' => [
                            'codigo' => $pedidoExame->createdLotacao->ocupacao->codigo ?? null,
                        ],
                        'profissional' => [
                            'nome' => $pedidoExame->createdLotacao->usuario->cidadao->nome ?? null,
                        ],
                    ],
                    'files' => $pedidoExame->laudos
                        ->where('created_at', '>=', $pedidoExame->created_at)
                        ->map(fn($laudo) => [
                            'id' => $laudo->id,
                            'name' => $laudo->nome,
                            'hash' => $laudo->hash
                        ])
                ];

                foreach ($pedidoExame->exames as $item) {
                    $pedido['exames'][] = [
                        'codigo' => $item->exame->codigo ?? null,
                        'nome' => $item->exame->nome ?? null,
                        'tipo_id' => $item->exame->tipo_id ?? null,
                        'status' => [
                            'id' => $item->status->id ?? null,
                            'nome' => $item->status->nome ?? null,
                        ],
                    ];
                }

                $pedidosExames[] = $pedido;
            }
        }

        return $pedidosExames;
    }

    private function getLotacaoLogado()
    {
        return Lotacao::findOrFail(auth()->payload()->get('lotacao_id'));
    }

    private function getEscalasComaGlasgow($atendimento)
    {
        return EscalaComaGlasgow::whereHas('pacienteObservacao', function($query) use ($atendimento) {

            $query->where('atendimento_id', $atendimento->id);
        })->orWhereHas('atendimentoTriagem', function($query) use ($atendimento) {

            $query->where('atendimento_id', $atendimento->id);
        })
        ->get()
        ->map(function ($escalaComaGlasgow) use ($atendimento) {
            return array_merge(
                $this->getBaseHistoricoAreaAtendimento($escalaComaGlasgow, $atendimento),
                [
                    'id' => $escalaComaGlasgow->id,
                    'pontuacao' => $this->getEscalaComaGlasgowPontuacao($escalaComaGlasgow),
                    'abertura_ocular' => $escalaComaGlasgow->aberturaOcular,
                    'resposta_verbal' => $escalaComaGlasgow->respostaVerbal,
                    'resposta_motora' => $escalaComaGlasgow->respostaMotora,
                    'reatividade_pupilar' => $escalaComaGlasgow->reatividadePupilar,
                    'observacoes' => $escalaComaGlasgow->observacao,
                    'resultado' => $this->getEscalaComaGlasgowResultado($escalaComaGlasgow),
                ]
            );
        });
    }

    private function getEscalaComaGlasgowResultado($escalaComaGlasgow)
    {
        $pontuacao = $this->getEscalaComaGlasgowPontuacao($escalaComaGlasgow);

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

                return 'A pontuação não pode ser calculada. Um ou mais itens não foram testados';
            }

        $glasgowInterpretacaoResultado = GlasgowInterpretacaoResultado::all();

        $result = $glasgowInterpretacaoResultado->filter(function ($glasgowInterpretacaoResultado, $key) use ($pontuacao) {

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

        return $result->descricao;
    }

    private function getEscalaComaGlasgowPontuacao($escalaComaGlasgow)
    {
        $result = $escalaComaGlasgow->aberturaOcular->pontos
            + $escalaComaGlasgow->respostaVerbal->pontos
            + $escalaComaGlasgow->respostaMotora->pontos
            - $escalaComaGlasgow->reatividadePupilar->pontos;

        return $result;
    }

    private function getGlasgowAberturaOcular()
    {
        return GlasgowAberturaOcular::all()
            ->map(function ($aberturaOcular) {

                return [
                    'id' => $aberturaOcular->id,
                    'descricao' => $aberturaOcular->descricao,
                    'pontos' => $aberturaOcular->pontos,
                ];
            });
    }

    private function getGlasgowReatividadePupilar()
    {
        return GlasgowReatividadePupilar::all()
            ->map(function ($reatividadePupilar) {

                return [
                    'id' => $reatividadePupilar->id,
                    'descricao' => $reatividadePupilar->descricao,
                    'pontos' => $reatividadePupilar->pontos,
                ];
            });
    }

    private function getGlasgowRespostaMotora()
    {
        return GlasgowRespostaMotora::all()
            ->map(function ($respostaMotora) {

                return [
                    'id' => $respostaMotora->id,
                    'descricao' => $respostaMotora->descricao,
                    'pontos' => $respostaMotora->pontos,
                ];
            });
    }

    private function getGlasgowRespostaVerbal()
    {
        return GlasgowRespostaVerbal::all()
            ->map(function ($respostaVerbal) {

                return [
                    'id' => $respostaVerbal->id,
                    'descricao' => $respostaVerbal->descricao,
                    'pontos' => $respostaVerbal->pontos,
                ];
            });
    }

    private static function getCaracteristicaDor()
    {
        $caracteristicasEnum = [
            DorToracicaEnum::CONTRICAO,
            DorToracicaEnum::QUEIMACAO,
            DorToracicaEnum::COMPRESSAO,
            DorToracicaEnum::PESO,
            DorToracicaEnum::DOR_SURDA
        ];

        $result = OrigemDorToracica::whereIn('id', $caracteristicasEnum)
            ->orderBy('nome')
            ->get()
            ->map(fn ($dorToracica) => [
                'id' => $dorToracica->id,
                'nome' => $dorToracica->nome,
            ]);

        return $result;
    }

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

        $result = OrigemDorToracica::whereIn('id', $caracteristicasEnum)
            ->orderBy('nome')
            ->get()
            ->map(fn ($dorToracica) => [
                'id' => $dorToracica->id,
                'nome' => $dorToracica->nome,
            ]);

        return $result;
    }

    private static function getFatorDesencadeante()
    {
        $caracteristicasEnum = [
            DorToracicaEnum::EXERCICIO,
            DorToracicaEnum::EXCITACAO,
            DorToracicaEnum::ESTRESSE,
            DorToracicaEnum::FRIO,
            DorToracicaEnum::REFEICOES_COPIOSAS,
        ];

        $result = OrigemDorToracica::whereIn('id', $caracteristicasEnum)
            ->orderBy('nome')
            ->get()
            ->map(fn ($dorToracica) => [
                'id' => $dorToracica->id,
                'nome' => $dorToracica->nome,
            ]);

        return $result;
    }

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

        $result = OrigemDorToracica::whereIn('id', $caracteristicasEnum)
            ->orderBy('nome')
            ->get()
            ->map(fn ($dorToracica) => [
                'id' => $dorToracica->id,
                'nome' => $dorToracica->nome,
            ]);

        return $result;
    }

    private static function getDuracaoDor()
    {
        $result = OrigemDorToracica::orderBy('id')
            ->whereIn('id', [DorToracicaEnum::DURACAO_DA_DOR, DorToracicaEnum::DURACAO_DA_DOR_MAIOR_10_MINUTOS])
            ->get()
            ->map(fn ($duracao) => [
                'id' => $duracao->id,
                'nome' => $duracao->nome,
            ]);

        return $result;
    }
}