<?php

namespace App\Http\Controllers\Impressao\Ambulatorio;

use App\Enums\Ambulatorio\ArcadaDentaria;
use App\Enums\Cadastro\SujeitoAtencao\TipoRegistroUsuario;
use App\Enums\Cadastro\UnidadeMedida;
use App\Http\Controllers\Controller;
use App\Models\Ambulatorio\Atendimento;
use App\Models\Ambulatorio\AtendimentoPreAtendimento;
use App\Models\Ambulatorio\AtendimentoSoapExameSolicitado;
use App\Models\Ambulatorio\AtendimentoSoapProblemaCondicao;
use App\Models\Ambulatorio\AtendimentoSoapProcedimentoEmad;
use App\Models\Ambulatorio\AtendimentoSoapTriagemNeonatalSolicitado;
use App\Models\Ambulatorio\Dente;
use App\Models\Ambulatorio\PuericulturaAlteracaoFenotipica;
use App\Models\Ambulatorio\PuericulturaFatorRisco;
use App\Models\Ambulatorio\PuericulturaMarcoDesenvolvimento;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentar;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentarPerguntaResposta;
use App\Models\Geral\Ciap;
use App\Models\Sigtap\Cid;
use App\Models\Sigtap\Procedimento;
use App\Services\Ambulatorio\AtendimentoService;
use App\Services\Geral\AgeService;
use App\Services\Geral\ImcService;
use App\Utils\DataUtil;
use App\Utils\Exports\PdfAtendimento;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class AtendimentoController extends Controller
{

    private const TEMPLATE = 'ambulatorio.atendimento';

    public function __invoke($atendimentoId)
    {
        $atendimento = Atendimento::findOrFail($atendimentoId);
        $paciente = $atendimento->paciente;

        $paraAssinaturaEletronica = request()->para_assinatura_eletronica === true
            || (DataUtil::isStringBoolean(request()->para_assinatura_eletronica)
            && DataUtil::isStringTrue(request()->para_assinatura_eletronica));

        $title = 'CONSULTA';
        $soaps = [];

        $atendimento->soaps()
            ->where('is_rascunho', false)
            ->get()
            ->each(function ($soap) use (&$soaps, $paciente, &$title) {
                $lotacao = $soap->createdLotacao;
                $infraestrutura = $soap->createdCentroCusto->infraestrutura;

                $dataNascimento = Carbon::parse($paciente->cidadao->data_nascimento);
                $dataCriacao = Carbon::parse($soap->created_at);
                $diferenca = $dataNascimento->diff($dataCriacao);
                $idade = [];

                if ($diferenca->y > 0) {
                    $idade[] = $diferenca->y . ' ' . ($diferenca->y === 1 ? 'ano' : 'anos');
                }

                if ($diferenca->m > 0) {
                    $idade[] = $diferenca->m . ' ' . ($diferenca->m === 1 ? 'mês' : 'meses');
                }

                if ($diferenca->d > 0) {
                    $idade[] = $diferenca->d . ' ' . ($diferenca->d === 1 ? 'dia' : 'dias');
                }

                $idadeGestacional = ['semanas' => null, 'dias' => null];
                $dataInicioGravidez = $soap->dum ? $soap->dum->format('d/m/Y') : null;

                if (!is_null($dataInicioGravidez)) {

                    $interval = Carbon::today()->diff(Carbon::createFromFormat('d/m/Y', $dataInicioGravidez));

                    $idadeGestacional['semanas'] = (int) floor($interval->days / 7);
                    $idadeGestacional['dias'] = $interval->days % 7;
                }


                if ($soap->is_atendimento_saude_bucal) {

                    $title = 'CONSULTA ODONTOLÓGICA';
                } else if ($soap->is_atendimento_pre_natal) {

                    $title = 'PRÉ-NATAL';
                } else if ($soap->is_atendimento_puericultura) {
                    $title = 'PUERICULTURA';
                }

                $idadeAnos = null;

                if ($soap->atendimento->paciente->cidadao->data_nascimento) {

                    $idadeAnos = AgeService::getAge(
                        (new Carbon($soap->atendimento->paciente->cidadao->data_nascimento)),
                        $soap->created_at->toDateTime()
                    )->years;
                }
                
                $soaps[] = [
                    'dataHora' => self::trataData($soap),
                    'local_atendimento' => $soap->atencaoBasicaLocalAtendimento->descricao ?? null,
                    'is_atendimento_saude_bucal' => $soap->is_atendimento_saude_bucal,
                    'is_atendimento_pre_natal' => $soap->is_atendimento_pre_natal,
                    'is_atendimento_puericultura' => $soap->is_atendimento_puericultura,
                    'is_atendimento_idoso' => $soap->is_atendimento_idoso,
                    'subjetivo' => [
                        'descricao' => $soap->subjetivo_descricao,
                        'motivos' => self::getAtendimentoMotivos($soap),
                    ],
                    'antecedente' => self::getAtendimentoAntecedente($soap),
                    'avaliacao' => [
                        'descricao' => $soap->avaliacao_descricao,
                        'condicoes_avaliadas' => $soap->condicoesAvaliadas->pluck('descricao'),
                        'doencas_transmissiveis' => $soap->doencasTransmissiveis->pluck('descricao'),
                        'rastreamentos' => $soap->rastreamentos->pluck('descricao'),
                        'problemas_condicoes' => self::getAtendimentoProblemasCondicoes($soap),
                        'alergias' => self::getAlergias($soap),
                        'condicoes_emad' => self::getAtendimentoCondicoesEmad($soap),
                    ],
                    'plano' => [
                        'descricao' => $soap->plano_descricao,
                        'intervencoes' => self::getAtendimentoIntervencoes($soap),
                        'procedimentos_clinicos' => self::getAtendimentoProcedimentosClinicos($soap),
                        'prescricoes_medicamentos' => self::getAtendimentoPrescricoesMedicamentos($soap),
                        'solicitacoes_exames' => self::getAtendimentoSolicitacoesExames($soap),
                        'testes_rapidos' => self::getAtendimentoTestesRapidos($soap),
                        'atestados' => $soap->atestados ? $soap->atestados->count() : null,
                        'declaracoes_comparecimento' => self::getAtendimentoDeclaracoesComparecimento($soap),
                        'orientacoes' => self::getAtendimentoOrientacoes($soap),
                        'encaminhamentos' => self::getAtendimentoEncaminhamentos($soap),
                        'compartilhamentos_cuidado' => self::getAtendimentoCompartilhamentosCuidado($soap),
                        'procedimentos_emad' => self::getAtendimentoProcedimentosEmad($soap),
                    ],
                    'objetivo' => [
                        'descricao' => $soap->objetivo_descricao,
                        'dum' => $soap->dum ? $soap->dum->format('d/m/Y') : null,
                        'antropometria' => self::getAtendimentoObjetivoAntropometria($soap),
                        'sinal_vital' => self::getAtendimentoObjetivoSinalVital($soap),
                        'glicemia_capilar' => self::getAtendimentoObjetivoGlicemiaCapilar($soap),
                        'marcador_consumo_alimentar' => self::getAtendimentoMarcadorConsumoAlimentar($soap),
                        'tria' => self::getAtendimentoObjetivoTria($soap),
                        'vacinacao_em_dia' => $soap->vacinacao_em_dia,
                        'paciente_com_necessidade_especial' => $soap->paciente_com_necessidade_especial,
                        'resultados_exames' => self::getAtendimentoResultadosExames($soap),
                    ],
                    'finalizacao' => [
                        'procedimentos_administrativos' => self::getAtendimentoProcedimentosAdministrativos($soap),
                        'racionalidade_saude' => self::getAtendimentoRacionalidadeSaude($soap),
                        'condutas' => self::getAtendimentoCondutas($soap),
                        'emad_tipo_atendimento' => optional($soap->emadTipoAtendimento)->descricao,
                        'emad_modalidade' => optional($soap->emadModalidade)->descricao,
                        'emad_conduta_desfecho' => optional($soap->emadCondutaDesfecho)->descricao,
                        'emad_procedencia' => optional($soap->emadProcedencia)->descricao,
                        'emad_cuidador' => optional($soap->emadCuidador)->descricao,
                        'emad_conclusao' => optional($soap->emadConclusao)->descricao,
                        'emad_cid_primario' => $soap->emad_cid_primario_id ? Cid::where('id', $soap->emad_cid_primario_id)->first() : null,
                        'emad_cns_cuidador' => $soap->emad_cns_cuidador ? MaskUtil::getCnsMasked($soap->emad_cns_cuidador) : null,
                        'emad_cpf_cuidador' => $soap->emad_cpf_cuidador ? MaskUtil::getCpfMasked($soap->emad_cpf_cuidador) : null,
                        'emad_justificativa' => optional($soap->justificativaEmad->first())->descricao,
                    ],
                    'saude_bucal' => [
                        'vigilancias' => self::getAtendimentoSaudeBucalVigilancias($soap),
                        'necessidade_protese_inferior_superior' => $soap->saude_bucal_necessidade_protese_inferior_superior,
                        'odontograma' => self::getAtendimentoOdontograma($soap),
                        'consulta_tipo' => self::getAtendimentoSaudeBucalConsultaTipo($soap),
                        'fornecimentos' => self::getAtendimentoSaudeBucalFornecimentos($soap),
                    ],
                    'pre_natal' => [
                        'is_gravidez_alto_risco' => self::isGravidezAltoRisco($soap),
                        'gravidez_tipo' => self::getAtendimentoPreNatalGravidezTipo($soap),
                        'altura_uterina' => $soap->pre_natal_altura_uterina,
                        'edema' => self::getAtendimentoPreNatalEdema($soap),
                        'movimentacao_fetal' => $soap->pre_natal_movimentacao_fetal ? 'Sim' : 'Não',
                        'batimento_cardiaco_fetal' => $soap->pre_natal_batimento_cardiaco_fetal,
                        'desfecho_em' => $soap->pre_natal_desfecho_em ? $soap->pre_natal_desfecho_em->format('d/m/Y') : null,
                        'idade_gestacional_semanas' => $idadeGestacional['semanas'],
                        'idade_gestacional_dias' => $idadeGestacional['dias'],
                    ],
                    'puericultura' => [
                        'alteracoes_fenotipicas' => self::getAtendimentoPuericulturaAlteracoesFenotipicas($soap),
                        'fatores_risco' => self::getAtendimentoPuericulturaFatoresRisco($soap),
                        'marcos_desenvolvimento' => self::getAtendimentoPuericulturaMarcosDesenvolvimento($soap),
                    ],
                    'usuario' => [
                        'nome' => $lotacao->usuario->cidadao->nome,
                        'registro_tipo' => $lotacao->usuario->registroTipo->sigla ?? null,
                        'registro_numero' => $lotacao->usuario->registro_numero ?? '-',
                        'unidade' => [
                            'nome' => $infraestrutura->unidade->nome_fantasia ?? '-',
                            'endereco' => $infraestrutura->endereco->completo ?? '-',
                            'telefone' => MaskUtil::getPhoneMasked($infraestrutura->telefone),
                        ],
                    ],
                    'paciente' => [
                        'nome' => $paciente->cidadao->nome,
                        'nome_social' => $paciente->cidadao->nome_social ?? null,
                        'nome_mae' => $paciente->cidadao->nome_mae ? $paciente->cidadao->nome_mae : 'NÃO INFORMADO',
                        'data_nascimento' => $paciente->cidadao->data_nascimento
                            ? $paciente->cidadao->data_nascimento->format('d/m/Y')
                            : 'NÃO INFORMADA',
                        'idade' => implode(', ', $idade),
                        'unidade' => $paciente->unidade->nomeFantasia ?? '-',
                        'cpf' => $paciente->cidadao->cpf ? MaskUtil::getCpfMasked($paciente->cidadao->cpf) : 'NÃO INFORMADO',
                        'cns' => $paciente->cidadao->cns ? MaskUtil::getCnsMasked($paciente->cidadao->cns) : 'NÃO INFORMADO',
                        'telefones' => $paciente->cidadao->telefones->map(fn ($t) => MaskUtil::getPhoneMasked($t->numero))->all(),
                        'municipio' => isset($paciente->cidadao->domicilio->endereco->logradouro->municipio)
                            ? $paciente->cidadao->domicilio->endereco->logradouro->municipio->nome . ' / ' .
                            $paciente->cidadao->domicilio->endereco->logradouro->municipio->estado->uf
                        : null,
                        'prontuario' => $paciente->prontuario,
                        'raca_cor' => $paciente->cidadao->racaCor->descricao,
                        'unidade_referencia' => $paciente->unidade->nome_fantasia ?? null,
                    ],
                    'informacoes_administrativas' => [
                        'usuario_nome' => $lotacao->usuario->cidadao->nome,
                        'ocupacao_descricao' => $lotacao->ocupacao->codigo . ' - ' . $lotacao->ocupacao->nome,
                        'documento' => $lotacao->usuario->registro_tipo_id
                            ? ($lotacao->usuario->registro_tipo_id === TipoRegistroUsuario::OUTRO
                                ? $lotacao->usuario->registro_tipo_outro
                                : $lotacao->usuario->registroTipo->sigla
                            )  . ": {$lotacao->usuario->registro_numero}"
                            : 'Conselho profissional: NÃO INFORMADO',
                    ],
                ];
            });

        $data = [
            'soaps' => $soaps,
            'paraAssinar' => $paraAssinaturaEletronica,
            'unidade_nome_fantasia' => $atendimento->infraestrutura->unidade->nome_fantasia ?? null,
        ];

        return PdfAtendimento::generate($title, self::TEMPLATE, $data);
    }

    private static function getAtendimentoCondicoesEmad($soap)
    {
        return $soap->condicoesEmad()->pluck('nome');
    }

    private static function getAtendimentoProcedimentosEmad($soap)
    {
        $procedimentos = AtendimentoSoapProcedimentoEmad::where('soap_id', $soap->id)->get();

        $dadosProcedimentos = [];

        foreach ($procedimentos as $item) {
            $proc = Procedimento::where('codigo', $item->codigo_procedimento)->orderByDesc('competencia_id')->first();

            if ($proc) {
                $dadosProcedimentos[] = [
                    'nome' => $proc->nome,
                    'codigo' => $proc->codigo,
                ];
            }
        }

        return $dadosProcedimentos;
    }

    private static function getAtendimentoIntervencoes($soap)
    {
        $intervencoes = $soap->intervencoes()
            ->with('ciap:id,codigo,descricao')
            ->get(['ciap_id', 'observacao']);

        $intervencoes->each(function ($intervencao) {

            $intervencao->makeHidden('ciap_id');
            $intervencao->ciap->makeHidden('id');
        });

        return $intervencoes;
    }

    private static function isGravidezAltoRisco($soap)
    {
        if (!$soap->is_atendimento_pre_natal) {

            return false;
        }

        $problemaCondicaoGravidez = $soap->problemasCondicoes()
            ->whereNotNull('paciente_gestacao_id')
            ->first(['paciente_gestacao_id']);

        if (!$problemaCondicaoGravidez) {

            return false;
        }


        $soapsGravidez = AtendimentoSoapProblemaCondicao::whereHas('soap', fn ($q) => $q
                ->where('is_rascunho', false)
            )->where(
                'paciente_gestacao_id',
                $problemaCondicaoGravidez->paciente_gestacao_id
            )
            ->where('soap_id', '<=', $soap->id)
            ->pluck('soap_id');

        if (!$soapsGravidez) {

            return false;
        }

        return DB::table('ambulatorio_atendimento_soap_problema_condicao as problema_condicao')
        ->whereIn('problema_condicao.soap_id', $soapsGravidez)
            ->where(
                fn($q) => $q
                    ->whereExists(
                        fn($q) => $q
                            ->select(DB::raw(1))
                            ->from('geral_ciap as ciap')
                            ->whereColumn('ciap.id', 'problema_condicao.ciap_id')
                            ->whereIn('ciap.codigo', AtendimentoService::CIAPS_GRAVIDEZ_ALTO_RISCO)
                    )
                    ->orWhereExists(
                        fn($q) => $q
                            ->select(DB::raw(1))
                            ->from('sigtap.cid as cid')
                            ->whereColumn('cid.id', 'problema_condicao.cid_id')
                            ->whereIn('cid.codigo', AtendimentoService::CIDS_GRAVIDEZ_ALTO_RISCO)
                    )
            )
            ->exists();
    }

    private static function getAtendimentoSaudeBucalVigilancias($soap)
    {
        return $soap->saudeBucalVigilancias()->orderBy('nome')->pluck('nome');
    }

    private static function getAtendimentoPreNatalGravidezTipo($soap)
    {
        return $soap->preNatalGravidezTipo()->first(['nome']);
    }

    private static function getAtendimentoPreNatalEdema($soap)
    {
        return $soap->preNatalEdema()->first(['nome']);
    }
    private static function getAtendimentoSaudeBucalFornecimentos($soap)
    {
        return $soap->saudeBucalFornecimentos()->orderBy('nome')->pluck('nome');
    }

    private static function getAtendimentoSaudeBucalConsultaTipo($soap)
    {
        return $soap->saudeBucalConsultaTipo()->first(['descricao']);
    }

    private static function getAtendimentoOdontograma($soap)
    {
        if (!$soap->is_atendimento_saude_bucal) {

            return null;
        }

        $procedimentos = collect();

        $odontograma = $soap->odontograma;

        $arcadaSuperior = $odontograma->odontogramaArcadas()
            ->where('arcada_id', ArcadaDentaria::SUPERIOR)
            ->first();

        $arcadaInferior = $odontograma->odontogramaArcadas()
            ->where('arcada_id', ArcadaDentaria::INFERIOR)
            ->first();

        $getDentesData = function ($arcadaId, $dente) use ($arcadaSuperior, $arcadaInferior) {

            $arcada = $arcadaId === ArcadaDentaria::SUPERIOR ? $arcadaSuperior : $arcadaInferior;

            $odontogramaArcadaDente = $arcada->odontogramaArcadaDentes()
                ->where('dente_id', $dente->id)
                ->first();

            return [
                'numero' => $dente->numero,
                'fragmentos' => [
                    'esquerda' => ['is_tratado' => $odontogramaArcadaDente->is_fragmento_esquerda_tratado],
                    'cima' => ['is_tratado' => $odontogramaArcadaDente->is_fragmento_cima_tratado],
                    'direita' => ['is_tratado' => $odontogramaArcadaDente->is_fragmento_direita_tratado],
                    'baixo' => ['is_tratado' => $odontogramaArcadaDente->is_fragmento_baixo_tratado],
                    'centro' => ['is_tratado' => $odontogramaArcadaDente->is_fragmento_centro_tratado],
                ],
                'problemas_condicoes' => $odontogramaArcadaDente->problemasCondicoes()
                    ->orderBy('nome')
                    ->pluck('nome'),
            ];
        };

        $protesesTotais = collect();

        if ($arcadaSuperior->possui_protese_total) {

            $protesesTotais->push('Total superior');
        }

        if ($arcadaInferior->possui_protese_total) {

            $protesesTotais->push('Total inferior');
        }

        $setProcedimentoData = function ($model, $local) use ($procedimentos) {

            $data = (object) array_merge(self::getLogData($model), [
                'local' => $local,
                'procedimentos' => collect(),
                'observacao' => $model->observacao,
            ]);

            $model->atendimentoProcedimentos
                ->each(function ($atendimentoProcedimento) use ($data) {

                    $procedimento = $atendimentoProcedimento->atendimentoProcedimento->procedimento;
                    $codigo = MaskUtil::getProcedimentoMasked($procedimento->codigo);

                    $data->procedimentos->push([
                        'codigo' => $codigo,
                        'nome' => $procedimento->nome,
                        'quantidade' => $atendimentoProcedimento->atendimentoProcedimento->quantidade,
                    ]);
                });

            $procedimentos->push($data);
        };

        $odontograma->odontogramaArcadas
            ->each(function ($odontogramaArcada) use ($setProcedimentoData) {

                if ($odontogramaArcada->atendimentoProcedimentos->isNotEmpty()) {

                    $setProcedimentoData(
                        $odontogramaArcada,
                        $odontogramaArcada->arcada_id === ArcadaDentaria::SUPERIOR
                            ? 'Arcada superior' : 'Arcada inferior'
                    );
                }

                $odontogramaArcada->odontogramaArcadaDentes()
                    ->whereHas('atendimentoProcedimentos')
                    ->get()
                    ->each(fn($odontogramaArcadaDente) => $setProcedimentoData(
                        $odontogramaArcadaDente,
                        "Dente {$odontogramaArcadaDente->dente->numero}"
                    ));
            });

        $odontograma->dentesSupranumerarios->each(fn($dente) => $setProcedimentoData($dente, $dente->local));

        return [
            'mostrar_dentes_deciduos' => false,
            'possui_aparelho' => $odontograma->possui_aparelho,
            'possui_contencao' => $odontograma->possui_contencao,
            'proteses_totais' => $protesesTotais,
            'possui_protese_total_superior' => $arcadaSuperior->possui_protese_total,
            'possui_protese_total_inferior' => $arcadaInferior->possui_protese_total,
            'proteses_totais' => $protesesTotais,
            'arcadas' => [
                'superior' => [
                    'dentes' => [
                        'permanentes' => Dente::where('arcada_id', ArcadaDentaria::SUPERIOR)
                            ->where('is_deciduo', false)
                            ->orderBy('ordem')
                            ->get()
                            ->map(fn($dente) => $getDentesData(ArcadaDentaria::SUPERIOR, $dente)),
                        'deciduos' => Dente::where('arcada_id', ArcadaDentaria::SUPERIOR)
                            ->where('is_deciduo', true)
                            ->orderBy('ordem')
                            ->get()
                            ->map(fn($dente) => $getDentesData(ArcadaDentaria::SUPERIOR, $dente)),
                    ],
                ],
                'inferior' => [
                    'dentes' => [
                        'permanentes' => Dente::where('arcada_id', ArcadaDentaria::INFERIOR)
                            ->where('is_deciduo', false)
                            ->orderBy('ordem')
                            ->get()
                            ->map(fn($dente) => $getDentesData(ArcadaDentaria::INFERIOR, $dente)),
                        'deciduos' => Dente::where('arcada_id', ArcadaDentaria::INFERIOR)
                            ->where('is_deciduo', true)
                            ->orderBy('ordem')
                            ->get()
                            ->map(fn($dente) => $getDentesData(ArcadaDentaria::INFERIOR, $dente)),
                    ],
                ],
            ],
            'procedimentos' => $procedimentos->sort()->values()
        ];
    }

    private static function getLogData($model)
    {
        return [
            'tipo' => $model instanceof AtendimentoPreAtendimento ? 'pre-atendimento' : 'atendimento',
            'data_hora' => $model->created_at,
            'lotacao' => [
                'ocupacao' => [
                    'codigo' => $model->createdLotacao->ocupacao->codigo,
                    'nome' => $model->createdLotacao->ocupacao->nome,
                ],
                'profissional' => [
                    'nome' => $model->createdLotacao->usuario->cidadao->nome,
                ],
            ],
            'centro_custo' => [
                'setor' => [
                    'nome' => $model->createdCentroCusto->setor->nome,
                ],
            ],
        ];
    }

    private static function getAtendimentoProblemasCondicoes($soap)
    {
        $problemasCondicoes = $soap->problemasCondicoes()
            ->with([
                'ciap:id,codigo,descricao',
                'cid:id,codigo,nome',
                'situacao:id,nome',
            ])
            ->get([
                'ciap_id',
                'cid_id',
                'situacao_id',
                'inicio',
                'fim',
                'observacao',
                'resolvido_automaticamente',
            ]);

        $problemasCondicoes->each(function ($problemaCondicao) {

            $problemaCondicao->makeHidden(['ciap_id', 'cid_id']);

            if (!is_null($problemaCondicao->ciap)) {

                $problemaCondicao->ciap->makeHidden('id');
            }

            if (!is_null($problemaCondicao->cid)) {

                $problemaCondicao->cid->makeHidden('id');
            }

            if (!is_null($problemaCondicao->situacao)) {

                $problemaCondicao->situacao->makeHidden('id');
            }
        });

        return $problemasCondicoes;
    }

    private static function getAlergias($soap)
    {
        return $soap->alergias
            ->map(fn($alergia) => [
                'data' => Carbon::parse($alergia->created_at)->format('d/m/Y'),
                'agente_substancia_especifica' => $alergia->alergia->agente_substancia_especifica,
                'tipo' => $alergia->alergia->tipo,
                'criticidade' => $alergia->criticidade,
                'reacoes_observacoes' => $alergia->reacoes_observacoes,
            ]);
    }

    private static function getAtendimentoPuericulturaAlteracoesFenotipicas($soap)
    {
        $getResposta = function ($alteracaoId) use ($soap) {

            $resposta = (object) ['is_presente' => null];

            $alteracao = $soap->puericulturaAlteracoesFenotipicas()
                ->where('alteracao_fenotipica_id', $alteracaoId)
                ->first();

            if (!is_null($alteracao) && $alteracao->is_presente !== $resposta->is_presente) {

                $resposta->is_presente = $alteracao->is_presente;
            }

            return $resposta;
        };

        $presente = '';
        $ausente = '';

        PuericulturaAlteracaoFenotipica::orderBy('id')
            ->get()
            ->each(function ($alteracao) use ($getResposta, &$presente, &$ausente) {

                $resposta = $getResposta($alteracao->id);

                if ($resposta->is_presente === true) {
                    $presente .= $alteracao->descricao . ' | ';
                } elseif ($resposta->is_presente === false) {
                    $ausente .= $alteracao->descricao . ' | ';
                }
            });

        $presente = rtrim($presente, ' | ');
        $ausente = rtrim($ausente, ' | ');

        return [
            'presente' => $presente,
            'ausente' => $ausente,
        ];
    }

    private static function getAtendimentoPuericulturaFatoresRisco($soap)
    {
        $getResposta = function ($fatorId) use ($soap) {

            $resposta = (object) ['is_presente' => null];

            $fator = $soap->puericulturaFatoresRisco()
                ->where('fator_risco_id', $fatorId)
                ->first();

            if (!is_null($fator) && $fator->is_presente !== $resposta->is_presente) {

                $resposta->is_presente = $fator->is_presente;
            }

            return $resposta;
        };

        $presente = '';
        $ausente = '';

        PuericulturaFatorRisco::orderBy('id')
            ->get()
            ->each(function ($fator) use ($getResposta, &$presente, &$ausente) {

                $resposta = $getResposta($fator->id);

                if ($resposta->is_presente === true) {
                    $presente .= $fator->descricao . ' | ';
                } elseif ($resposta->is_presente === false) {
                    $ausente .= $fator->descricao . ' | ';
                }
            });

        $presente = rtrim($presente, ' | ');
        $ausente = rtrim($ausente, ' | ');

        return [
            'presente' => $presente,
            'ausente' => $ausente,
        ];
    }

    private static function getAtendimentoPuericulturaMarcosDesenvolvimento($soap)
    {
        $dataNascimento = $soap->atendimento->paciente->cidadao->data_nascimento;

        if (is_null($dataNascimento)) {

            return [];
        }

        $getResposta = function ($marcoId) use ($soap) {

            $resposta = (object) [
                'is_presente' => null,
                'alcancado_com_anos' => null,
                'alcancado_com_meses' => null,
            ];

            $marco = $soap->puericulturaMarcosDesenvolvimento()
                ->where('marco_desenvolvimento_id', $marcoId)
                ->first();

            if (!is_null($marco)) {

                if ($marco->is_presente !== $resposta->is_presente) {

                    $resposta->is_presente = $marco->is_presente;

                    if (
                        $marco->is_presente
                        && (!is_null($marco->alcancado_com_anos) || !is_null($marco->alcancado_com_meses))
                    ) {

                        $resposta->alcancado_com_anos = $marco->alcancado_com_anos;
                        $resposta->alcancado_com_meses = $marco->alcancado_com_meses;
                    } else {

                        $resposta->alcancado_com_anos = null;
                        $resposta->alcancado_com_meses = null;
                    }
                } else if (
                    $marco->is_presente
                    && $resposta->is_presente
                    && ($marco->alcancado_com_anos !== $resposta->alcancado_com_anos
                        || $marco->alcancado_com_meses !== $resposta->alcancado_com_meses
                    )
                ) {

                    $resposta->alcancado_com_anos = $marco->alcancado_com_anos;
                    $resposta->alcancado_com_meses = $marco->alcancado_com_meses;
                }
            }

            return $resposta;
        };

        $marcos = collect();
        $idadeEmMeses = ceil($soap->created_at->diffInDays($dataNascimento) / 31);

        PuericulturaMarcoDesenvolvimento::orderBy('faixa_etaria_dias_fim')
            ->get()
            ->each(function ($marco) use ($marcos, $idadeEmMeses, $getResposta) {

                $faixaEtariaEmMeses = floor($marco->faixa_etaria_dias_fim / 31);

                if ($faixaEtariaEmMeses <= $idadeEmMeses) {

                    $marcoFaixaEtaria = $marcos->where('descricao', $marco->faixa_etaria_descricao)->first();

                    if (is_null($marcoFaixaEtaria)) {

                        $marcoFaixaEtaria = (object) [
                            'descricao' => $marco->faixa_etaria_descricao,
                            'perguntas' => collect(),
                            'show_alcancado_com' => $marco->faixa_etaria_dias_fim > 15,
                            'meses_final' => $faixaEtariaEmMeses,
                        ];

                        $marcos->push($marcoFaixaEtaria);
                    }

                    $resposta = $getResposta($marco->id);

                    $marcoFaixaEtaria->perguntas->push((object) [
                        'id' => $marco->id,
                        'descricao' => $marco->descricao,
                        'is_presente' => $resposta->is_presente,
                        'alcancado_com_anos' => $resposta->alcancado_com_anos,
                        'alcancado_com_meses' => $resposta->alcancado_com_meses,
                    ]);
                }
            });

        $presente = '';
        $presenteComAtraso = '';
        $ausente = '';

        $marcos->each(function ($marco) use (&$presente, &$presenteComAtraso, &$ausente) {

            $marco->perguntas->each(function ($pergunta) use ($marco, &$presente, &$presenteComAtraso, &$ausente) {

                if (!is_null($pergunta->is_presente)) {

                    $meses = ($pergunta->alcancado_com_anos * 12) + $pergunta->alcancado_com_meses;

                    if (
                        $pergunta->is_presente
                        && $marco->meses_final > 0
                        && $meses > $marco->meses_final
                    ) {

                        $presenteComAtraso .= $pergunta->descricao . ' | ';
                    } else {

                        if ($pergunta->is_presente === true) {
                            $presente .= $pergunta->descricao . ' | ';
                        } elseif ($pergunta->is_presente === false) {
                            $ausente .= $pergunta->descricao . ' | ';
                        }
                    }
                }
            });
        });

        $presente = rtrim($presente, ' | ');
        $presenteComAtraso = rtrim($presenteComAtraso, ' | ');
        $ausente = rtrim($ausente, ' | ');

        return [
            'presente' => $presente,
            'presente_com_atraso' => $presenteComAtraso,
            'ausente' => $ausente,
        ];
    }

    private static function getAtendimentoRacionalidadeSaude($soap)
    {
        return $soap->racionalidadeSaude()->first(['descricao']);
    }

    private static function getAtendimentoEncaminhamentos($soap)
    {
        $encaminhamentos = $soap->encaminhamentos()
            ->with([
                'tipo:id,descricao',
                'servicoEspecializadoEspecialidade:id,nome,ocupacao_id',
                'servicoEspecializadoEspecialidade.ocupacao:id,codigo,nome',
                'servicoEspecializadoCid:id,codigo,nome',
                'servicoEspecializadoClassificacaoRisco:id,nome',
            ])
            ->get([
                'tipo_id',
                'servico_especializado_especialidade_id',
                'servico_especializado_complemento',
                'servico_especializado_cid_id',
                'servico_especializado_classificacao_risco_id',
                'servico_especializado_motivo',
                'servico_especializado_observacao',
                'intersetorial_infraestrutura_id',
            ]);

        $encaminhamentos->each(function ($encaminhamento) {

            $encaminhamento->makeHidden([
                'servico_especializado_especialidade_id',
                'servico_especializado_classificacao_risco_id',
                'intersetorial_infraestrutura_id',
            ]);

            if (!is_null($encaminhamento->servicoEspecializadoEspecialidade)) {

                $encaminhamento->servicoEspecializadoEspecialidade->makeHidden(['id', 'ocupacao_id']);
                $encaminhamento->servicoEspecializadoEspecialidade->ocupacao->makeHidden('id');
            }

            if (!is_null($encaminhamento->servicoEspecializadoCid)) {

                $encaminhamento->servicoEspecializadoCid->makeHidden('id');
            }

            if (!is_null($encaminhamento->servicoEspecializadoClassificacaoRisco)) {

                $encaminhamento->servicoEspecializadoClassificacaoRisco->makeHidden('id');
            }

            if (is_null($encaminhamento->intersetorial_infraestrutura_id)) {

                $encaminhamento->intersetorial_infraestrutura = null;
            } else {

                $intersetorialInfraestrutura = $encaminhamento->intersetorialInfraestrutura()
                    ->setEagerLoads([])
                    ->first(['id', 'nome', 'principal', 'unidade_id']);

                $encaminhamento->intersetorial_infraestrutura = (object) [
                    'nome' => $intersetorialInfraestrutura->nome,
                    'unidade' => (object) [
                        'nome_fantasia' => $intersetorialInfraestrutura->unidade()
                            ->first('nome_fantasia')
                            ->nome_fantasia
                    ]
                ];
            }
        });

        return $encaminhamentos;
    }

    private static function getAtendimentoOrientacoes($soap)
    {
        return $soap->orientacoes()->get(['descricao']);
    }

    private static function getAtendimentoSolicitacoesExames($soap)
    {

        $solicitacoesExames = collect();

        $soap->solicitacoesExames->each(function ($solicitacao) use ($solicitacoesExames) {

            $itens = $solicitacao->itens()
                ->get()
                ->map(fn ($item) => [
                    'exame' => [
                        'codigo' => MaskUtil::getProcedimentoMasked($item->exame->codigo),
                        'nome' => $item->exame->nome,
                    ],
                ]);

            if ($itens->isNotEmpty()) {

                $cid = $solicitacao->cid_id ? Cid::where('id', $solicitacao->cid_id)->first() : null;
                $ciap = $solicitacao->ciap_id ? Ciap::where('id', $solicitacao->ciap_id)->first() : null;

                $solicitacoesExames->push([
                    'data' => $solicitacao->created_at->format('d/m/Y'),
                    'cid' => $cid ? $cid->codigo .' - '. $cid->nome : null,
                    'ciap' => $ciap ? $ciap->codigo .' - '. $ciap->descricao : null,
                    'classificacao_risco' => $solicitacao->classificacaoRisco->descricao_encaminhamento ?? null,
                    'justificativa' => $solicitacao->justificativa,
                    'observacao' => $solicitacao->observacao,
                    'itens' => $itens,
                ]);
            }
        });

        AtendimentoSoapExameSolicitado::where('soap_id', $soap->id)
            ->get()
            ->map(function ($solicitacao) use ($solicitacoesExames) {

                $itens = $solicitacao->examesSolicitados()
                    ->get()
                    ->map(fn ($item) => [
                        'exame' => [
                            'codigo' => MaskUtil::getProcedimentoMasked($item->codigo_procedimento),
                            'nome' => $item->descricao,
                        ],
                    ]);

                if ($itens->isNotEmpty()) {

                    $cid = $solicitacao->cid_id ? Cid::where('id', $solicitacao->cid_id)->first() : null;
                    $ciap = $solicitacao->ciap_id ? Ciap::where('id', $solicitacao->ciap_id)->first() : null;

                    $solicitacoesExames->push([
                        'data' => $solicitacao->created_at->format('d/m/Y'),
                        'cid' => $cid ? $cid->codigo .' - '. $cid->nome : null,
                        'ciap' => $ciap ? $ciap->codigo .' - '. $ciap->descricao : null,
                        'classificacao' => null,
                        'justificativa' => $solicitacao->justificativa,
                        'observacao' => $solicitacao->observacao,
                        'itens' => $itens,
                    ]);
                }
            });

        AtendimentoSoapTriagemNeonatalSolicitado::where('soap_id', $soap->id)
            ->get()
            ->map(function ($solicitacao) use ($solicitacoesExames) {

                $itens = $solicitacao->triagensNeonatalSolicitados()
                    ->get()
                    ->map(fn ($item) => [
                        'exame' => [
                            'codigo' => MaskUtil::getProcedimentoMasked($item->codigo_procedimento),
                            'nome' => $item->descricao,
                        ],
                    ]);

                if ($itens->isNotEmpty()) {

                    $cid = $solicitacao->cid_id ? Cid::where('id', $solicitacao->cid_id)->first() : null;
                    $ciap = $solicitacao->ciap_id ? Ciap::where('id', $solicitacao->ciap_id)->first() : null;

                    $solicitacoesExames->push([
                        'data' => $solicitacao->created_at->format('d/m/Y'),
                        'cid' => $cid ? $cid->codigo .' - '. $cid->nome : null,
                        'ciap' => $ciap ? $ciap->codigo .' - '. $ciap->descricao : null,
                        'classificacao' => null,
                        'justificativa' => $solicitacao->justificativa,
                        'observacao' => $solicitacao->observacao,
                        'itens' => $itens,
                    ]);
                }
            });

        return $solicitacoesExames;
    }

    private static function getAtendimentoProcedimentosAdministrativos($soap)
    {
        return $soap->procedimentosAdministrativos()
            ->get(['atendimento_procedimento_id'])
            ->map(function ($procedimentoAdministrativo) {

                $atendimentoProcedimento = $procedimentoAdministrativo->atendimentoProcedimento()->first([
                    'procedimento_id',
                    'quantidade',
                    'automatico',
                    'cid_id',
                ]);


                if (!$atendimentoProcedimento) {
                    return [];
                }

                return (object) [
                    'procedimento' => self::getProcedimento($atendimentoProcedimento->procedimento_id),
                    'quantidade' => $atendimentoProcedimento->quantidade,
                    'automatico' => $atendimentoProcedimento->automatico,
                    'cid' => self::getCid($atendimentoProcedimento->cid_id),
                ];
            });
    }

    private static function getAtendimentoProcedimentosClinicos($soap)
    {
        return $soap->procedimentosClinicos()
            ->get([
                'atendimento_procedimento_id',
                'observacao',
            ])
            ->map(function ($procedimentoClinico) {

                $atendimentoProcedimento = $procedimentoClinico->atendimentoProcedimento()->first([
                    'procedimento_id',
                    'cid_id',
                    'quantidade',
                    'automatico',
                ]);

                return (object) [
                    'procedimento' => self::getProcedimento($atendimentoProcedimento->procedimento_id),
                    'cid' => self::getCid($atendimentoProcedimento->cid_id),
                    'quantidade' => $atendimentoProcedimento->quantidade,
                    'automatico' => $atendimentoProcedimento->automatico,
                    'observacao' => $procedimentoClinico->observacao,
                ];
            });
    }

    private static function getProcedimento($procedimentoId)
    {
        return DB::table('sigtap.procedimento')
            ->where('id', $procedimentoId)
            ->select(
                'codigo',
                'nome'
            )
            ->first();
    }

    private static function getCid($cidId)
    {
        return DB::table('sigtap.cid')
            ->where('id', $cidId)
            ->select(
                'codigo',
                'nome'
            )
            ->first();
    }

    private static function getAtendimentoTestesRapidos($soap)
    {
        return DB::table('ambulatorio_atendimento_soap_teste_rapido as pivot')
            ->join('ambulatorio_atendimento_soap as soap', 'soap.id', 'pivot.soap_id')
            ->join('ambulatorio_teste_rapido as teste_rapido', 'teste_rapido.id', 'pivot.teste_rapido_id')
            ->where('soap.is_rascunho', false)
            ->where('soap.atendimento_id', $soap->atendimento_id)
            ->select(DB::raw("
                teste_rapido.id,
                teste_rapido.nome,
                pivot.resultado
            "))
            ->orderBy('nome')
            ->get();
    }

    private static function getAtendimentoCondutas($soap)
    {
        return $soap->condutas()->orderBy('descricao')->pluck('descricao');
    }

    private static function getAtendimentoCompartilhamentosCuidado($soap)
    {
        $compartilhamentosCuidado = $soap->compartilhamentosCuidado()
            ->with([
                'especialidade:id,nome,ocupacao_id',
                'especialidade.ocupacao:id,codigo,nome',
                'ciap:id,codigo,descricao',
                'cid:id,codigo,nome',
                'classificacaoRisco:id,nome',
            ])
            ->get([
                'especialidade_id',
                'usuario_id',
                'ciap_id',
                'cid_id',
                'classificacao_risco_id',
                'discussao_caso_clinico',
            ]);

        $compartilhamentosCuidado->each(function ($compartilhamentoCuidado) {

            $compartilhamentoCuidado->usuario = (object) [
                'nome' => $compartilhamentoCuidado->usuario()
                    ->setEagerLoads([])
                    ->first(['cidadao_id'])
                    ->cidadao()
                    ->setEagerLoads([])
                    ->first(['nome'])
                    ->nome,
            ];

            $compartilhamentoCuidado->makeHidden([
                'especialidade_id',
                'usuario_id',
                'ciap_id',
                'cid_id',
                'classificacao_risco_id',
            ]);

            if (!is_null($compartilhamentoCuidado->especialidade)) {

                $compartilhamentoCuidado->especialidade->makeHidden('id');
                $compartilhamentoCuidado->especialidade->ocupacao->makeHidden('id');
            }

            if (!is_null($compartilhamentoCuidado->ciap)) {

                $compartilhamentoCuidado->ciap->makeHidden('id');
            }

            if (!is_null($compartilhamentoCuidado->cid)) {

                $compartilhamentoCuidado->cid->makeHidden('id');
            }

            $compartilhamentoCuidado->classificacaoRisco->makeHidden('id');
        });

        return $compartilhamentosCuidado;
    }

    private static function getAtendimentoAntecedente($soap)
    {
        $antecedente = $soap->antecedente()
            ->with([
                'problemasCondicoes:antecedente_id,ciap_id,cid_id,situacao_id,inicio,fim,observacao',
                'problemasCondicoes.ciap:id,codigo,descricao',
                'problemasCondicoes.cid:id,codigo,nome',
                'problemasCondicoes.situacao:id,nome',
                'cirurgiasInternacoes:antecedente_id,descricao,realizada_em,observacao',
                'problemasFamiliares:antecedente_id,ciap_id,observacao',
                'problemasFamiliares.ciap:id,codigo,descricao',
            ])
            ->first([
                'id',
                'descricao',
                'gestas_previas',
                'abortos',
                'desfecho_gestacao_aconteceu_menos_um_ano',
                'partos_realizados',
                'partos_vaginais',
                'partos_cesareas',
                'partos_domiciliares',
                'nascidos_vivos',
                'nascidos_mortos',
                'recem_nascidos_com_menos2500_gramas',
                'recem_nascidos_com_mais4500_gramas',
                'nascidos_vivos_vivem',
                'nascidos_vivos_mortos_primeira_semana',
                'nascidos_vivos_mortos_depois_primeira_semana',
            ]);

        if (!is_null($antecedente)) {

            $antecedente->makeHidden('id');

            $antecedente->problemasCondicoes->each(function ($problemaCondicao) {

                $problemaCondicao->makeHidden([
                    'antecedente_id',
                    'ciap_id',
                    'cid_id',
                    'situacao_id',
                ]);

                if (!is_null($problemaCondicao->ciap)) {

                    $problemaCondicao->ciap->makeHidden('id');
                }

                if (!is_null($problemaCondicao->cid)) {

                    $problemaCondicao->cid->makeHidden('id');
                }

                $problemaCondicao->situacao->makeHidden('id');
            });

            $antecedente->cirurgiasInternacoes->makeHidden('antecedente_id');

            $antecedente->problemasFamiliares->each(function ($problemaFamiliar) {

                $problemaFamiliar->makeHidden([
                    'antecedente_id',
                    'ciap_id',
                ]);

                $problemaFamiliar->ciap->makeHidden('id');
            });
        }

        return $antecedente;
    }

    private static function getAtendimentoMotivos($soap)
    {
        $motivos = $soap->motivos()
            ->with('ciap:id,codigo,descricao')
            ->with('cid:id,codigo,nome')
            ->get(['ciap_id','cid_id','observacao']);

        $motivos->each(function ($motivo) {

            $motivo->makeHidden('ciap_id', 'cid_id');

            if ($motivo->ciap) {
                $motivo->ciap->makeHidden('id');
            }

            if ($motivo->cid) {
                $motivo->cid->makeHidden('id');
            }
        });

        return $motivos;
    }

    private static function trataData($soap)
    {

        $hora = null;

        if($soap->atendimento->agendamento_id){

            $dataCriacao = Carbon::parse($soap->atendimento->agendamento->jornada->data);
            $hora = Carbon::parse($soap->atendimento->agendamento->horario);
        }

        if($soap->atendimento->demanda_espontanea_id){

            $dataCriacao = Carbon::parse($soap->atendimento->demandaEspontanea->data);
        }

        $meses = [
            1 => 'janeiro',
            2 => 'fevereiro',
            3 => 'março',
            4 => 'abril',
            5 => 'maio',
            6 => 'junho',
            7 => 'julho',
            8 => 'agosto',
            9 => 'setembro',
            10 => 'outubro',
            11 => 'novembro',
            12 => 'dezembro'
        ];

        $dia = $dataCriacao->format('d');
        $mes = $meses[intval($dataCriacao->format('m'))];
        $ano = $dataCriacao->format('Y');

        if ($hora) {

            $horaFormatada = $hora->format('H:i');
            return "{$dia} de {$mes} de {$ano} às {$horaFormatada}";
        }

        return "{$dia} de {$mes} de {$ano}";
    }

    private static function getAtendimentoObjetivoAntropometria($soap)
    {
        $antropometria = $soap->objetivoAntropometria()
            ->with('atendimentoAntropometria:id,peso,altura,perimetro_cefalico,circunferencia_abdominal,perimetro_panturrilha,comprimento_pe_direito,largura_pe_direito,circunferencia_pe_direito,comprimento_pe_esquerdo,largura_pe_esquerdo,circunferencia_pe_esquerdo')
            ->first(['atendimento_antropometria_id']);

        if (!is_null($antropometria)) {

            $antropometria->atendimentoAntropometria->imc = !is_null($antropometria->atendimentoAntropometria->peso)
                && !is_null($antropometria->atendimentoAntropometria->altura)
                ? ImcService::calculate(
                    UnidadeMedida::QUILOGRAMAS,
                    $antropometria->atendimentoAntropometria->peso,
                    UnidadeMedida::CENTIMETROS,
                    $antropometria->atendimentoAntropometria->altura
                )
                : null;

            $antropometria->atendimentoAntropometria->makeHidden('id');

            return $antropometria->atendimentoAntropometria;
        }

        return $antropometria;
    }

    private static function getAtendimentoObjetivoSinalVital($soap)
    {
        $sinalVital = $soap->objetivoSinalVital()
            ->with('atendimentoSinalVital:id,pressao_arterial,frequencia_respiratoria,frequencia_cardiaca,temperatura,saturacao_o2')
            ->first(['atendimento_sinal_vital_id']);

        if (!is_null($sinalVital)) {

            $sinalVital->atendimentoSinalVital->makeHidden('id');

            return $sinalVital->atendimentoSinalVital;
        }

        return $sinalVital;
    }

    private static function getAtendimentoDeclaracoesComparecimento($soap)
    {
        $declaracoesComparecimento = $soap->declaracoesComparecimento()
            ->with('turno:id,nome')
            ->get([
                'nome_acompanhante',
                'turno_id',
                'entrada',
                'saida',
            ]);

        $declaracoesComparecimento->each(function ($declaracaoComparecimento) {

            $declaracaoComparecimento->makeHidden('turno_id');

            if (!is_null($declaracaoComparecimento->turno)) {

                $declaracaoComparecimento->turno->makeHidden('id');
            }
        });

        return $declaracoesComparecimento;
    }


    private static function getAtendimentoObjetivoGlicemiaCapilar($soap)
    {
        $glicemiaCapilar = $soap->objetivoGlicemiaCapilar()
            ->with([
                'atendimentoGlicemiaCapilar:id,momento_coleta_id,valor',
                'atendimentoGlicemiaCapilar.momentoColeta:id,nome',
            ])
            ->first(['atendimento_glicemia_capilar_id']);

        if (!is_null($glicemiaCapilar)) {

            $glicemiaCapilar->atendimentoGlicemiaCapilar->makeHidden('momento_coleta_id');
            $glicemiaCapilar->atendimentoGlicemiaCapilar->momentoColeta->makeHidden('id');

            return $glicemiaCapilar->atendimentoGlicemiaCapilar;
        }

        return $glicemiaCapilar;
    }

    private static function getAtendimentoObjetivoTria($soap)
    {
        $triaHistorio = $soap->triaHistorio()
            ->where('soap_id', $soap->id)
            ->first([
                'alimentos_acabaram',
                'comeu_alguns_alimentos',
                'data_atualizacao_tria',
            ]);

        if (is_null($triaHistorio)) {
            return null;
        }

        return [
            'alimentos_acabaram' => $triaHistorio->alimentos_acabaram,
            'comeu_alguns_alimentos' => $triaHistorio->comeu_alguns_alimentos,
            'data_atualizacao_tria' => $triaHistorio->data_atualizacao_tria
                ? $triaHistorio->data_atualizacao_tria->format('d/m/Y')
                : null,
        ];
    }

    private static function getAtendimentoPrescricoesMedicamentos($soap)
    {
        return $soap->prescricoesMedicamentos->map(fn($prescricao) => [
            'medicamentos' => $prescricao->itens()
                ->with([
                    'turno:id,nome',
                    'unidadeMedida:id,nome',
                    'intervaloMedidaTempo:id,nome',
                    'duracaoMedidaTempo:id,nome',
                ])
                ->get([
                    'descricao',
                    'justificativa',
                    'material_id',
                    'dose',
                    'is_dose_unica',
                    'is_uso_continuo',
                    'frequencia_vezes',
                    'turno_id',
                    'unidade_medida_id',
                    'intervalo',
                    'intervalo_medida_tempo_id',
                    'inicio',
                    'duracao',
                    'duracao_medida_tempo_id',
                    'recomendacoes',
                    'tratamento_interrompido_em',
                    'tratamento_interrompido_justificativa',
                ])
                ->map(function ($item) {

                    $material = $item->material()
                        ->with([
                            'apresentacao:id,nome',
                            'apresentacaoUnidadeMedida:id,nome',
                            'viaAdministracao:id,nome',
                        ])
                        ->first([
                            'descricao',
                            'apresentacao_id',
                            'quantidade',
                            'apresentacao_unidade_medida_id',
                            'via_administracao_id',
                        ]);

                    return (object) [
                        'is_manual' => $item->is_manual,
                        'descricao' => $item->descricao,
                        'justificativa' => $item->justificativa ?? null,
                        'material' => is_null($material) ? null : [
                            'descricao' => $material->descricao,
                            'via_administracao' => [
                                'nome' => $material->viaAdministracao->nome ?? null
                            ]
                        ],
                        'is_dose_unica' => $item->is_dose_unica,
                        'is_uso_continuo' => $item->is_uso_continuo,
                        'posologia' => $item->posologia,
                        'inicio' => is_null($item->inicio) ? null : $item->inicio->format('d/m/Y'),
                        'duracao' => $item->duracao,
                        'duracao_medida_tempo' => is_null($item->duracaoMedidaTempo) ? null : [
                            'nome' => $item->duracaoMedidaTempo->nome,
                        ],
                        'conclusao' => is_null($item->conclusao) ? null : $item->conclusao->format('d/m/Y'),
                        'recomendacoes' => $item->recomendacoes,
                        'is_tratamento_concluido' => $item->is_tratamento_concluido,
                        'is_tratamento_interrompido' => $item->is_tratamento_interrompido,
                        'tratamento_interrompido_em' => is_null($item->tratamento_interrompido_em)
                            ? null : $item->tratamento_interrompido_em->format('d/m/Y'),
                        'tratamento_interrompido_justificativa' => $item->tratamento_interrompido_justificativa,
                    ];
                })
        ]);
    }

    private static function getAtendimentoMarcadorConsumoAlimentar($soap)
    {
        $marcadorConsumoAlimentar = MarcadorConsumoAlimentar::where('soap_id', $soap->id)->first(['id']);

        $marcador = [];

        if ($marcadorConsumoAlimentar) {
            $marcador = MarcadorConsumoAlimentarPerguntaResposta::where('marcador_consumo_alimentar_id', $marcadorConsumoAlimentar->id)
                ->get()
                ->map(fn($modulo) => [
                    'pergunta_id' => $modulo->pergunta_id,
                    'resposta_id' => $modulo->resposta_id,
                    'pergunta' => $modulo->pergunta->descricao,
                    'resposta' => $modulo->resposta->descricao,
                ]);

            $marcador = $marcador->groupBy('pergunta');
        }

        return $marcador;
    }


    private static function getAtendimentoResultadosExames($soap)
    {
        $resultadosExames = $soap->resultadosExames()
            ->with('resultadoTipo:id,nome')
            ->get([
                'exame_id',
                'solicitado_em',
                'realizado_em',
                'resultado_em',
                'resultado',
                'percentual',
                'idade_gestacional_semanas_eco',
                'idade_gestacional_dias_eco',
                'dpp_eco',
                'resultado_tipo_id',
            ]);

            $resultados = collect();

            $resultadosExames->each(function ($resultadoExame) use (&$resultados) {

                $exame = self::getExame($resultadoExame->exame_id);

                $data = (object)[
                    'solicitado_em' => $resultadoExame->solicitado_em
                        ? $resultadoExame->solicitado_em->format('d/m/Y') : null,
                    'realizado_em' => $resultadoExame->realizado_em
                        ? $resultadoExame->realizado_em->format('d/m/Y') : null,
                    'resultado_em' => $resultadoExame->resultado_em
                        ? $resultadoExame->resultado_em->format('d/m/Y') : null,
                    'resultado' => $resultadoExame->resultado,
                    'exame' => [
                        'nome' => $exame->nome,
                        'codigo' => $exame->codigo,
                    ],
                ];

                $resultados->push($data);
            });

        $examesAvaliados = self::getExamesAvaliados($soap);
        $triagemNeonatal = self::getTriagensNeonatal($soap);

        $resultadoExames = [];

        for ($i = 0; $i < count($examesAvaliados); $i++) {
            $resultadoExames[] = $examesAvaliados[$i];
        }

        for ($j = 0; $j < count($resultados); $j++) {
            $resultadoExames[] = $resultados[$j];
        }

        for ($j = 0; $j < count($triagemNeonatal); $j++) {
            $resultadoExames[] = $triagemNeonatal[$j];
        }

        return $resultadoExames;
    }

    private static function getExame($exameId)
    {
        return DB::table('parametrizacao_exame')
            ->where('id', $exameId)
            ->select(
                'codigo',
                'nome'
            )
            ->first();
    }

    private static function getExamesAvaliados($soap)
    {
        $resultadosExames = $soap->examesAvaliados;

        $procedimentos = collect();

        $resultadosExames->each(function ($resultadoExame) use (&$procedimentos) {

            $data = (object)[
                'solicitado_em' => $resultadoExame->soapExameAvaliado->solicitado_em
                    ? Carbon::parse($resultadoExame->soapExameAvaliado->solicitado_em)->format('d/m/Y') : null,
                'realizado_em' => $resultadoExame->soapExameAvaliado->realizado_em
                    ? Carbon::parse($resultadoExame->soapExameAvaliado->realizado_em)->format('d/m/Y') : null,
                'resultado_em' => $resultadoExame->soapExameAvaliado->resultado_em
                    ? Carbon::parse($resultadoExame->soapExameAvaliado->resultado_em)->format('d/m/Y') : null,
                'resultado' => $resultadoExame->soapExameAvaliado->resultado,
                'exame' => [
                    'nome' => $resultadoExame->descricao,
                    'codigo' => $resultadoExame->codigo_procedimento,
                ],
            ];

            $procedimentos->push($data);
        });

        return $procedimentos;
    }


    private static function getTriagensNeonatal($soap)
    {

        $resultadosExames = $soap->triagensNeonatal;

        $procedimentos = collect();

        $resultadosExames->each(function ($resultadoExame) use (&$procedimentos) {

            $data = (object)[
                'solicitado_em' => $resultadoExame->soapTriagemNeonatal->solicitado_em
                    ? Carbon::parse($resultadoExame->soapTriagemNeonatal->solicitado_em)->format('d/m/Y') : null,
                'realizado_em' => $resultadoExame->soapTriagemNeonatal->realizado_em
                    ? Carbon::parse($resultadoExame->soapTriagemNeonatal->realizado_em)->format('d/m/Y') : null,
                'resultado_em' => $resultadoExame->soapTriagemNeonatal->resultado_em
                    ? Carbon::parse($resultadoExame->soapTriagemNeonatal->resultado_em)->format('d/m/Y') : null,
                'resultado' => $resultadoExame->soapTriagemNeonatal->resultado,
                'exame' => [
                    'nome' => $resultadoExame->descricao,
                    'codigo' => $resultadoExame->codigo_procedimento,
                ],
            ];

            $procedimentos->push($data);
        });

        return $procedimentos;
    }
}