<?php

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

use App\Enums\Cadastro\Estabelecimento\SetorTipo;
use App\Enums\Cadastro\SujeitoAtencao\FatorRisco as FatorRiscoEnum;
use App\Enums\Cadastro\SujeitoAtencao\FatorRisco as SujeitoAtencaoFatorRisco;
use App\Enums\Cadastro\SujeitoAtencao\Sexo;
use App\Enums\Cadastro\UnidadeMedida as UnidadeMedidaEnum;
use App\Enums\Geral\TipoMedidaAltura as TipoMedidaAlturaEnum;
use App\Enums\ProntoAtendimento\Atendimento\Desfecho as DesfechoEnum;
use App\Enums\ProntoAtendimento\Atendimento\DorToracica as DorToracicaEnum;
use App\Enums\ProntoAtendimento\TipoFormularioAcidenteTrabalho;
use App\Enums\Sigtap\Ocupacao;
use App\Enums\Sigtap\Procedimento as ProcedimentoEnum;
use App\Http\Controllers\Controller;
use App\Http\Requests\ProntoAtendimento\Atendimento\TriagemRequest;
use App\Models\Cadastro\Estabelecimento\Unidade;
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\UnidadeMedida;
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\PainelSenha\Encaminhamento;
use App\Models\PainelSenha\Fila;
use App\Models\PainelSenha\Prioridade;
use App\Models\PainelSenha\Status;
use App\Models\ProntoAtendimento\Atendimento\Atendimento;
use App\Models\ProntoAtendimento\Atendimento\Cat;
use App\Models\ProntoAtendimento\Atendimento\Desfecho;
use App\Models\ProntoAtendimento\Atendimento\EscalaComaGlasgow;
use App\Models\ProntoAtendimento\Atendimento\Triagem\AtendimentoTriagem;
use App\Models\ProntoAtendimento\Atendimento\Triagem\FormularioDorToracica;
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\Parametrizacao;
use App\Models\Sigtap\Procedimento;
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\Sigtap\ProcedimentoValidationService;
use Carbon\Carbon;
use Exception;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;

class AtendimentoTriagemController extends Controller
{
    protected $modulo = 'pronto-atendimento';
    protected $funcionalidade = 'atendimento-triagem';

    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-triagem';
        $arquivo = "{$id}.PDF";

        $atendimentoTriagem = AtendimentoTriagem::findOrFail($id);

        if (!is_null($atendimentoTriagem)) {
            $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 {
                $atendimentoTriagem->update(['is_faa_assinada' => true]);
            }
        }

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

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

        $lotacaoLogada = Lotacao::find(auth()->payload()->get('lotacao_id'));

        $atendimento = $this->getAtendimento($id);

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

                $exibirFatorRiscoGestante = true;
        } else {
            $exibirFatorRiscoGestante = false;
        }

        FilaService::answer($id);

        $encaminhamentos = [];

        foreach ($atendimento->atendimentosTriagem as $atendimentoTriagem) {
            foreach ($atendimentoTriagem->encaminhamentos as $encaminhamento) {
                $infraestrutura = $encaminhamento->infraestrutura;
                $unidade = $infraestrutura->unidade;

                $encaminhamentos[] = [
                    'id' => $encaminhamento->id ?? null,
                    'lotacao' => [
                        'ocupacao' => [
                            'codigo' => $encaminhamento->createdLotacao->ocupacao->codigo ?? null,
                        ],
                        'profissional' => [
                            'nome' => $encaminhamento->createdLotacao->usuario->cidadao->nome ?? null,
                        ],
                    ],
                    'unidade_id' => $unidade->id,
                    'unidade_nome_fantasia' => $unidade->nome_fantasia,
                    'infraestrutura_id' => $infraestrutura->id,
                    'infraestrutura_nome' => $infraestrutura->nome,
                    'urgente' => $encaminhamento->urgente ?? false,
                    'motivo' => $encaminhamento->motivo ?? null,
                    'observacoes' => $encaminhamento->observacoes ?? null,
                ];
            }
        }

        return response()->json(
            [
                'form' => [
                    'prioridades' => Prioridade::orderBy('nome')
                        ->get()
                        ->map(fn ($prioridade) => [
                            'id' => $prioridade->id,
                            'nome' => $prioridade->nome,
                        ]),
                    'prioridade_id' => $atendimento->fila->prioridade_id,
                    'alergia_criticidades' => $this->getAlergiaCriticidades(),
                    'alergia_tipos' => $this->getAlergiaTipos(),
                    'classificacoes_risco' => $this->getClassificacoesRisco(),
                    'fatores_risco' => $this->getFatoresRisco(),
                    'fatores_risco_gestante' => $this->getFatoresRiscoGestante(),
                    'data_atendimento' => $this->getDataAtendimento($atendimento),
                    'data_atual' => $this->getDataAtual(),
                    'desfecho' => Desfecho::get(),
                    'encaminhamento_setores' => $this->getEncaminhamentoSetores(),
                    'fila' => $this->getFila($id),
                    'historicos_enfermagem' => $this->getHistoricosEnfermagem($atendimento),
                    'historico_atendimento' => $this->getHistoricoAtendimento($atendimento),
                    'lotacao' => $this->getLotacao(),
                    'medicamentos_uso' => $this->getMedicamentosUso($atendimento),
                    'observacoes' => $this->getObservacoes($atendimento),
                    'outras_avaliacoes_condicoes' => $this->getOutrasAvaliacoesCondicoes($atendimento),
                    'paciente' => $this->getPaciente($atendimento),
                    'raat' => RaatService::getOptionsParecerMedico(),
                    'recepcao' => $this->getRecepcao($atendimento),
                    'sinais_vitais' => $this->getSinaisVitais($atendimento),
                    'unidades_medida' => $this->getUnidadesMedida(),
                    '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(),
                    ],
                    'encaminhamentos' => $encaminhamentos,
                    'unidades' => Unidade::orderBy('nome_fantasia')
                        ->get()
                        ->map(function ($unidade) {
                            return [
                                'id' => $unidade->id,
                                'nome_fantasia' => $unidade->nome_fantasia,
                                'infraestruturas' => $unidade->infraestruturas
                                    ->map(function ($infraestrutura) {
                                        return [
                                            'id' => $infraestrutura->id,
                                            'nome' => $infraestrutura->nome,
                                        ];
                                    })
                            ];
                        })
                ],
                'model' => [
                    'dor_toracica' => $atendimento->dor_toracica,
                    'alergias' => $this->getAlergias($atendimento),
                    'medicamentos_uso_continuo' => $this->getMedicamentosUsoContinuo($atendimento, Carbon::now()),
                    'fatores_risco' => $this->getCidadaoFatoresRisco($atendimento),
                    'fator_risco_outro' => $atendimento->faa->paciente->cidadao->fator_risco_outro,
                    'atendimento_id' => $atendimento->id,
                    'avaliacao_antropometrica' => $this->getAvaliacaoAntropometrica($atendimento),
                    'centro_custo_id_para' => null,
                    'classificacao_risco_id' => $this->getClassificacaoRisco($atendimento),
                    'gestacao' => $this->getGestacao($atendimento),
                    'historico_enfermagem' => null,
                    'medicamentos_uso' => null,
                    'observacoes' => null,
                    'outras_avaliacoes_condicoes' => null,
                    'acidente_trabalho' => $this->getAcidenteTrabalho(),
                    'sinais_vitais' => [],
                    'exibirFatorRiscoGestante' => $exibirFatorRiscoGestante,
                    'escalas_coma_glasgow' => [],
                    'finalizacao' => [
                        'desfecho_id' => null,
                        'evasao' => [
                            'motivo' => null,
                        ],
                    ],
                    'dor_toracica_hora_sintoma' => null,
                    'dor_toracica_hora_ecg_admissao' => null,
                    'dor_toracica_data_sintoma' => null,
                    'dor_toracica_data_ecg_admissao' => null,
                    'dor_toracica_formulario' => [],
                    'dor_toracica_caracteristica_dor' => [],
                    'dor_toracica_localizacao_dor' => [],
                    'dor_toracica_fator_descadeante' => [],
                    'dor_toracica_duracao_dor' => [],
                    'dor_toracica_fatores_riscos' => [],
                    'dor_toracica_dispneia' => null,
                    'cancelamento_desfecho' => false,
                    'encaminhamentos' => [],
                ],
                'additionals' => [
                    'timeline' => AtendimentoService::getTimelineItems($id),
                    'is_enfermeiro' => collect([
                        Ocupacao::ENFERMEIRO,
                        Ocupacao::ENFERMEIRO_ESTOMATERAPEUTA,
                        Ocupacao::ENFERMEIRO_AUDITOR,
                        Ocupacao::ENFERMEIRO_BORDO,
                        Ocupacao::ENFERMEIRO_CENTRO_CIRURGICO,
                        Ocupacao::ENFERMEIRO_TERAPIA_INTENSIVA,
                        Ocupacao::ENFERMEIRO_TRABALHO,
                        Ocupacao::ENFERMEIRO_NEFROLOGISTA,
                        Ocupacao::ENFERMEIRO_NEONATOLOGISTA,
                        Ocupacao::ENFERMEIRO_OBSTETRICO,
                        Ocupacao::ENFERMEIRO_PSIQUIATRICO,
                        Ocupacao::ENFERMEIRO_PUERICULTOR_PEDIATRICO,
                        Ocupacao::ENFERMEIRO_SANITARISTA,
                        Ocupacao::ENFERMEIRO_ESTRATEGIA_SAUDE_FAMILIA,
                    ])->contains($lotacaoLogada->ocupacao->codigo),
                    'allow_desfecho' => !$atendimento->atendimentosMedico()->exists() && !$atendimento->atendimentosEnfermagem()->exists() && !$atendimento->atendimentosExameImagem()->exists() && !$atendimento->pacienteObservacoes()->exists()
                ],
            ],
            Response::HTTP_OK
        );
    }

    private function getOutrasAvaliacoesCondicoes($atendimento)
    {
        return $atendimento->atendimentosTriagem()->whereNotNull('outras_avaliacoes_condicoes')
            ->get()
            ->map(function($query) {
                return [
                    'centro_custo' => [
                        'setor' => [
                            'nome' => $query->createdCentroCusto->setor->nome ?? null,
                        ],
                    ],
                    'classificacao_risco' => [
                        'nome' => $query->classificacaoRisco->classificacaoRisco->nome ?? null,
                    ],
                    'data_hora' => $query->created_at->format('d/m/Y H:i:s'),
                    'descricao' => $query->outras_avaliacoes_condicoes,
                    'lotacao' => [
                        'ocupacao' => [
                            'nome' => $query->createdLotacao->ocupacao->nome ?? null,
                        ],
                        'profissional' => [
                            'nome' => $query->createdLotacao->usuario->cidadao->nome ?? null,
                        ],
                    ],
                ];
            })
            ->values();
    }

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

        $atendimentoTriagem = new AtendimentoTriagem();

        DB::transaction(function() use (&$atendimentoTriagem, $request) {
            $atendimento = Atendimento::findOrFail($request['atendimento_id']);

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

            $atendimentoTriagem->plantao_id = $request['plantao_id'];
            $atendimentoTriagem->atendimento_id = $atendimento->id;
            $atendimentoTriagem->outras_avaliacoes_condicoes = $request['outras_avaliacoes_condicoes'];

            if ($request->input('cancelamento_desfecho') === true) {

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

            $atendimentoTriagem->save();

            $encaminhamentosData = $this->prepareEncaminhamentosData($request->ALL());

            if (!empty($encaminhamentosData)) {

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

            $this->saveProcedimentoTriagem($atendimentoTriagem);

            if ($request->classificacao_risco_id) {
                $atendimento->classificacoesRisco()->create([
                    'atendimento_triagem_id' => $atendimentoTriagem->id,
                    'classificacao_risco_id' => $request->classificacao_risco_id,
                ]);
            }

            if ($request['alergias']) {
                $atendimento->faa->paciente->cidadao->alergias()->sync($this->prepareAlergiasData($request['alergias']));
            }

            $atendimento->faa->paciente->cidadao->fatoresRisco()->sync($request['fatores_risco'] ?? []);

            $atendimento->faa->paciente->cidadao->medicamentosUsoContinuo()->sync($this->prepareMedicamentosUsoContinuoData($request['medicamentos_uso_continuo'] ?? []) ?? []);

            $this->handleFatorRiscoOutro($atendimento, $request);

            if ($request['avaliacao_antropometrica']
                && ($request['avaliacao_antropometrica']['altura'] || $request['avaliacao_antropometrica']['massa'])
            ) {

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

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

                    $atendimento->avaliacoesAntropometricas()->create([
                        'atendimento_triagem_id' => $atendimentoTriagem->id,
                        'massa' => $request['avaliacao_antropometrica']['massa'] ?? null,
                        'massa_unidade_medida_id' => isset($request['avaliacao_antropometrica']['massa'])
                            ? $request['avaliacao_antropometrica']['massa_unidade_medida_id']
                            : null,
                        'altura' => $request['avaliacao_antropometrica']['altura'] ?? null,
                        'altura_unidade_medida_id' => isset($request['avaliacao_antropometrica']['altura'])
                            ? $request['avaliacao_antropometrica']['altura_unidade_medida_id']
                            : null,
                        'altura_tipo_medida_id' => isset($request['avaliacao_antropometrica']['altura'])
                            ? $request['avaliacao_antropometrica']['altura_tipo_medida_id']
                            : null,
                    ]);

                    if ($atendimentoTriagem->avaliacaoAntropometrica) {

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

                        $validation = new ProcedimentoValidationService($procedimento);

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

                            if ($atendimentoTriagem->atendimento->procedimentos->contains('procedimento_id', $procedimento->id) === false) {
                                $atendimento->procedimentos()->create([
                                    'lotacao_id' => auth()->payload()->get('lotacao_id'),
                                    'atendimento_triagem_id' => $atendimentoTriagem->id,
                                    'procedimento_id' => $procedimento->id,
                                    'quantidade' => 1,
                                ]);
                            }
                        }
                    }
                }
            }

            if ($request['gestacao'] && $request['gestacao']['gestante']) {
                $cidadao = $atendimento->faa->paciente->cidadao;

                if ($cidadao->sexo_id === Sexo::FEMININO && $cidadao->idade && $cidadao->idade['anos'] >= 9 && $cidadao->idade['anos'] <= 60) {
                    $atendimento->gestacoes()->create([
                        'atendimento_triagem_id' => $atendimentoTriagem->id,
                        'dum' => $request['gestacao']['gestante'] ? ($request['gestacao']['dum'] ?? null) : null,
                        'gestante' => $request['gestacao']['gestante'],
                    ]);

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

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

                    $atendimento->faa->paciente->cidadao->load('fatoresRisco');

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

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

            if ($request['historico_enfermagem']) {

                $atendimento->historicosEnfermagem()->create([
                    'atendimento_triagem_id' => $atendimentoTriagem->id,
                    'descricao' => $request['historico_enfermagem'],
                ]);
            }

            if ($request['medicamentos_uso']) {
                $atendimento->medicamentosUso()->create([
                    'atendimento_triagem_id' => $atendimentoTriagem->id,
                    'descricao' => $request['medicamentos_uso'],
                ]);
            }

            if ($request['observacoes']) {
                $atendimento->observacoes()->create([
                    'atendimento_triagem_id' => $atendimentoTriagem->id,
                    'descricao' => $request['observacoes'],
                ]);
            }

            if ($request['sinais_vitais']) {
                foreach ($request['sinais_vitais'] as $sinalVital) {
                    $item = $atendimento->sinaisVitais()->create([
                        'atendimento_triagem_id' => $atendimentoTriagem->id,
                        'cintura' => $sinalVital['cintura'] ?? null,
                        'glicemia' => $sinalVital['glicemia'] ?? null,
                        'intensidade_dor' => $sinalVital['intensidade_dor'] ?? null,
                        'pa' => $sinalVital['pa'] ?? null,
                        'pa_unidade_medida_id' => $sinalVital['pa'] ? $sinalVital['pa_unidade_medida_id'] ?? null : null,
                        'pulso' => $sinalVital['pulso'] ?? null,
                        'respiracao' => $sinalVital['respiracao'] ?? null,
                        'saturacao' => $sinalVital['saturacao'] ?? null,
                        'temperatura' => $sinalVital['temperatura'] ?? null,
                    ]);

                    if ($item->pa) {

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

                        $validation = new ProcedimentoValidationService($procedimento);

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

                            $atendimento->procedimentos()->create([
                                'lotacao_id' => auth()->payload()->get('lotacao_id'),
                                'atendimento_triagem_id' => $atendimentoTriagem->id,
                                'procedimento_id' => $procedimento->id,
                                'quantidade' => 1,
                            ]);
                        }
                    }

                    if ($item->glicemia) {

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

                        $validation = new ProcedimentoValidationService($procedimento);

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

                            $atendimento->procedimentos()->create([
                                'lotacao_id' => auth()->payload()->get('lotacao_id'),
                                'atendimento_triagem_id' => $atendimentoTriagem->id,
                                'procedimento_id' => $procedimento->id,
                                'quantidade' => 1,
                            ]);
                        }
                    }
                }
            }

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

            $atendimento->dor_toracica = $request['dor_toracica'];
            $atendimento->save();

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

                $ids[] = $atendimento->id;

                $dorToracicaFormulario = $request->dor_toracica_formulario;

                $formulario = new FormularioDorToracica();
                $formulario->atendimento_id = $atendimento->id;
                $formulario->data_sintoma = $request->dor_toracica_data_sintoma;
                $formulario->hora_sintoma = $request->dor_toracica_hora_sintoma;
                $formulario->data_ecg_admissao = $request->dor_toracica_data_ecg_admissao;
                $formulario->hora_ecg_admissao = $request->dor_toracica_hora_ecg_admissao;
                $formulario->dispneia = $request->dor_toracica_dispneia;
                $formulario->save();

                foreach ($dorToracicaFormulario as $itens) {

                    $formularioRelacionado = new RelacionadoFormularioDorToracica();
                    $formularioRelacionado->formulario_id = $formulario->id;
                    $formularioRelacionado->atendimento_id = $atendimento->id;
                    $formularioRelacionado->dor_toracica_id = $itens;

                    $formularioRelacionado->save();
                }

            }

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

                $this->storeFinalizacao($request['finalizacao'], $atendimentoTriagem);
            } else {

                FilaService::forward([
                    'centro_custo_id_para' => $request['centro_custo_id_para'],
                    'prioridade_id' => $request['prioridade_id'],
                ], $request['fila_id']);
            }

            if (isset($request['raat'])) {
                $tipoFormularioAcidenteTrabalho = $request['raat']['tipo_formulario_acidente_trabalho'];
                $raat = $this->saveRaat($atendimento->faa, $request['raat']);

                if($tipoFormularioAcidenteTrabalho !== TipoFormularioAcidenteTrabalho::RAAT) {
                    $this->saveCat($raat->id, $request['raat']['empresa_ocupacao_paciente']);
                }
            }
        });

        $atendimentoTriagem->refresh();
        $atendimentoTriagem->impressoes = $this->getImpressoes($atendimentoTriagem);
        $atendimentoTriagem->faa_id = $atendimentoTriagem->atendimento->faa_id;
        $atendimentoTriagem->assinar = Parametrizacao::first()->assinatura_eletronica ?? false;

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

    private function saveProcedimentoTriagem($atendimentoTriagem)
    {
        $procedimento = Procedimento::where('codigo', ProcedimentoEnum::ACOLHIMENTO_COM_CLASSIFICACAO_DE_RISCO)
            ->orderByDesc('competencia_id')
            ->firstOrFail();

        $validation = new ProcedimentoValidationService($procedimento);

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

            $atendimentoTriagem->atendimento->procedimentos()->create([
                'lotacao_id' => auth()->payload()->get('lotacao_id'),
                'atendimento_triagem_id' => $atendimentoTriagem->id,
                'procedimento_id' => $procedimento->id,
                'quantidade' => 1,
            ]);
        }
    }

    private function getImpressoes($atendimentoTriagem)
    {
        $recepcao = $atendimentoTriagem->atendimento->recepcao;
        $cidadao = $recepcao->atendimento->faa->paciente->cidadao;
        $fila = $atendimentoTriagem->atendimento->fila;

        $impressoesFAA = ImpressaoService::getImpressoesFaa($recepcao->atendimento_id);

        return [
            'recepcao' => ImpressaoService::getImpressoesRecepcao(
                $recepcao->atendimento_id,
                [
                    'etiqueta' => [
                        'atendido_em' => (new Carbon($recepcao->atendido_em))->format('d/m/Y H:i'),
                        'infraestrutura' => $recepcao->createdLotacao->infraestrutura->nome,
                        'acompanhante' => $recepcao->acompanhante ?? '',
                        'paciente' => $cidadao->nome,
                        'data_nascimento' => $cidadao->data_nascimento
                            ? $cidadao->data_nascimento->format('d/m/Y') : '',
                        'senha' => $recepcao->atendimento->fila->senha
                    ],
                    'senha' => [
                        'data' => $fila->data_emissao,
                        'hora' => $fila->hora_emissao,
                        'senha' => $fila->senha,
                    ]
                ]
            ),
            'triagem' => ImpressaoService::getImpressoesTriagem($recepcao->atendimento_id),
            'faa' => $impressoesFAA
        ];
    }

    private function prepareAlergiasData($alergiasParams)
    {
        $alergias = [];

        foreach (($alergiasParams ?? []) 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 ?? []) as $medicamento) {

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

        return $medicamentos;
    }

    private function getAlergiaCriticidades()
    {
        return AlergiaCriticidade::all()->map(function($query) {
            return [
                'id' => $query->id,
                'nome' => $query->nome,
            ];
        });
    }

    private function getAlergiaTipos()
    {
        return AlergiaTipo::all()->map(function($query) {
            return [
                'descricao' => $query->descricao,
                'id' => $query->id,
            ];
        });
    }

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

    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;

        return $cidadao->fatoresRisco->pluck('id');
    }

    private function getAtendimento($id)
    {
        return Atendimento::where('fila_id', $id)
            ->orderBy('created_at', 'desc')
            ->firstOrFail();
    }

    private function getAvaliacaoAntropometrica($atendimento)
    {
        $avaliacaoAntropometrica = $atendimento->avaliacoesAntropometricas()->orderByDesc('created_at')->first();

        return [
            'altura' => $avaliacaoAntropometrica->altura ?? null,
            'altura_tipo_medida_id' => $avaliacaoAntropometrica->altura_tipo_medida_id ?? TipoMedidaAlturaEnum::ESTATURA,
            'altura_unidade_medida_id' => $avaliacaoAntropometrica->altura_unidade_medida_id ?? UnidadeMedidaEnum::METROS,
            'imc' => [
                'classificacao' => $avaliacaoAntropometrica->imc['classificacao'] ?? null,
                'imc' => $avaliacaoAntropometrica->imc['imc'] ?? null,
            ],
            'massa' => $avaliacaoAntropometrica->massa ?? null,
            'massa_unidade_medida_id' => $avaliacaoAntropometrica->massa_unidade_medida_id ?? UnidadeMedidaEnum::QUILOGRAMAS,
        ];
    }

    private function getClassificacaoRisco($atendimento)
    {
        $classificacaoRisco = $atendimento->classificacoesRisco->sortByDesc('created_at')->first();
        return $classificacaoRisco ? $classificacaoRisco->classificacaoRisco->id : null;
    }

    private function getClassificacoesRisco()
    {
        return ClassificacaoRisco::all()->map(function($query) {
            return [
                'cor' => $query->tipo->cor,
                'cor_nome' => $query->tipo->cor_nome,
                'id' => $query->id,
                'nome' => $query->nome,
            ];
        });
    }

    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')
            ->where('id', '=', DorToracicaEnum::DURACAO_DA_DOR)
            ->get()
            ->map(fn ($duracao) => [
                'id' => $duracao->id,
                'nome' => $duracao->nome,
            ]);

        return $result;
    }

    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 getDataAtendimento($atendimento)
    {
        return $atendimento->created_at->format('d/m/Y');
    }

    private function getDataAtual()
    {
        return Carbon::now()->format('d/m/Y');
    }

    private function getEncaminhamentoSetores()
    {
        return Encaminhamento::with('centroCustoPara.setor')
            ->where('centro_custo_id_de', auth()->payload()->get('centro_custo_id'))
            ->get()
            ->filter(function ($encaminhamento) {
                return $encaminhamento->centroCustoPara && $encaminhamento->centroCustoPara->setor;
            })
            ->reject(function ($encaminhamento) {
                return $encaminhamento->centroCustoPara->setor->tipo_id === SetorTipo::RECEPCAO;
            })
            ->map(function($query) {
                return [
                    'id' => $query->centroCustoPara->id,
                    'nome' => $query->centroCustoPara->setor->nome,
                ];
            });
    }

    private function getFila($id)
    {
        $fila = Fila::findOrFail($id);

        return [
            'status' => [
                'tipo' => [
                    'id' => $fila->status->tipo->id ?? null,
                ],
            ],
            'prioridade' => $fila->prioridade
        ];
    }

    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,
            ],
        ];
    }

    private function getHistoricosEnfermagem($atendimento)
    {
        return $atendimento->historicosEnfermagem->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();

            $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();

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

            $params = [
                '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,
                ],
            ];

            return $params;
        });
    }

    private function getLotacao()
    {
        $lotacao = Lotacao::findOrFail(auth()->payload()->get('lotacao_id'));

        return [
            'ocupacao' => [
                'codigo' => $lotacao->ocupacao->codigo,
                'nome' => $lotacao->ocupacao->nome,
            ],
            'profissional' => [
                'id' => $lotacao->usuario->codigo,
                'nome' => $lotacao->usuario->cidadao->nome,
            ],
        ];
    }

    private function getMedicamentosUso($atendimento)
    {
        return $atendimento->medicamentosUso->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 getObservacoes($atendimento)
    {
        return $atendimento->observacoes->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 getPaciente($atendimento)
    {
        return [
            'cns' => $atendimento->faa->paciente->cidadao->cns,
            'cpf' => $atendimento->faa->paciente->cidadao->cpf,
            'id' => $atendimento->faa->paciente->id,
            'data_nascimento' => $atendimento->faa->paciente->cidadao->data_nascimento,
            'idade' => $atendimento->faa->paciente->cidadao->idade,
            'nome' => $atendimento->faa->paciente->cidadao->nome,
            'nome_social' => $atendimento->faa->paciente->cidadao->nome_social,
            'pcd' => $atendimento->faa->paciente->cidadao->deficiencia ?? $atendimento->faa->paciente->cidadao->deficiencia_outro,
            'preferencia_nome_id' => $atendimento->faa->paciente->cidadao->preferencia_nome_id,
            'is_desconhecido' => $atendimento->faa->paciente->is_desconhecido,
            'prontuario' => $atendimento->faa->paciente->prontuario,
            'sexo' => $atendimento->faa->paciente->cidadao->sexo,
        ];
    }

    private function getRecepcao($atendimento)
    {
        return [
            'motivo_atendimento' => $atendimento->recepcao->motivo_atendimento,
        ];
    }

    private function getAcidenteTrabalho()
    {
        return [
            'tipo_formulario_acidente_trabalho' => TipoFormularioAcidenteTrabalho::RAAT,
            'acidente_data' => null,
            'acidente_descricao' => null,
            'acidente_hora' => null,
            'acidente_local' => null,
            'acidente_tipo_id' => null,
            'empresa_endereco' => null,
            'empresa_nome' => null,
            'empresa_ramo_atividade' => null,
            'empresa_ocupacao_paciente' => null,
            'empresa_telefone' => null,
            'regime_trabalho_id' => null,
            'regime_trabalho_outro' => null,
        ];
    }

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

    private function getUnidadesMedida()
    {
        return UnidadeMedida::all()->map(function($query) {
            return [
                'id' => $query->id,
                'nome' => $query->nome,
                'sigla' => $query->sigla,
            ];
        });
    }

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

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

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

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

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

        return $result;
    }

    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 function storeFinalizacao(array $params, AtendimentoTriagem $atendimentoTriagem)
    {
        $faaParams = [
            'desfecho_id' => $params['desfecho_id'],
            'finalizado' => true,
        ];

        switch ($params['desfecho_id']) {
            case DesfechoEnum::PACIENTE_ATENDIDO: {

                $faaParams['usuario_id'] = $atendimentoTriagem->createdLotacao->usuario_id;
                $faaParams['lotacao_id'] = $atendimentoTriagem->createdLotacao->id;
                $faaParams['data_hora_desfecho'] = $atendimentoTriagem->created_at;

                break;
            }
            case DesfechoEnum::EVASAO: {

                $faaParams['usuario_id'] = $atendimentoTriagem->createdLotacao->usuario_id;
                $faaParams['lotacao_id'] = $atendimentoTriagem->createdLotacao->id;
                $faaParams['data_hora_desfecho'] = $atendimentoTriagem->created_at;

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

                break;
            }
        }

        $atendimentoTriagem->atendimento->faa->update($faaParams);

        if ($params['desfecho_id'] != DesfechoEnum::EVASAO) {
            FilaService::dispatch($atendimentoTriagem->atendimento->fila->centroCusto);
        }
    }

    private function saveRaat($faa, $params)
    {
        return $faa->raat()->create([
            'tipo_formulario_acidente_trabalho' => $params['tipo_formulario_acidente_trabalho'],
            'empresa_nome' => $params['empresa_nome'],
            'empresa_ramo_atividade' => $params['empresa_ramo_atividade'] ?? null,
            'empresa_endereco' => $params['empresa_endereco'] ?? null,
            'empresa_telefone' => $params['empresa_telefone'] ?? null,
            'acidente_data' => $params['acidente_data'],
            'acidente_hora' => $params['acidente_hora'] ?? null,
            'acidente_tipo_id' => $params['acidente_tipo_id'] ?? null,
            'acidente_local' => $params['acidente_local'] ?? null,
            'acidente_descricao' => $params['acidente_descricao'],
            'regime_trabalho_id' => $params['regime_trabalho_id'] ?? null,
            'regime_trabalho_outro' => $params['regime_trabalho_outro'] ?? null
        ]);
    }

    private function saveCat($raatId, $ocupacaoPaciente)
    {
        return Cat::create([
            'raat_id' => $raatId,
            'empresa_ocupacao_paciente' => $ocupacaoPaciente
        ]);
    }

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

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

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

        return $encaminhamentos;
    }
}