<?php

namespace App\Services\Ambulatorio;

use App\Enums\Ambulatorio\ArcadaDentaria;
use App\Enums\Ambulatorio\Desfecho;
use App\Enums\Ambulatorio\SigiloTipo;
use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
use App\Enums\Cadastro\UnidadeMedida;
use App\Enums\Sigtap\Cid as SigtapCid;
use App\Models\Ambulatorio\AtendimentoPosConsulta;
use App\Models\Ambulatorio\AtendimentoPreAtendimento;
use App\Models\Ambulatorio\AtendimentoSoap;
use App\Models\Ambulatorio\AtendimentoSoapExameSolicitado;
use App\Models\Ambulatorio\AtendimentoSoapProblemaCondicao;
use App\Models\Ambulatorio\AtendimentoSoapProcedimentoEmad;
use App\Models\Ambulatorio\AtendimentoSoapTriagemNeonatalSolicitado;
use App\Models\Ambulatorio\AtendimentoSoapFerida;
use App\Models\Ambulatorio\Atendimento;
use App\Models\Ambulatorio\Dente;
use App\Models\Ambulatorio\ParametrizacaoSigilo;
use App\Models\Ambulatorio\PuericulturaAlteracaoFenotipica;
use App\Models\Ambulatorio\PuericulturaFatorRisco;
use App\Models\Ambulatorio\PuericulturaMarcoDesenvolvimento;
use App\Models\Ambulatorio\PuericulturaQuestionarioMChatR;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentar;
use App\Models\Integracao\Erpsaude\Atendimento as AtendimentoErpsaude;
use App\Models\Sigtap\Cid;
use App\Models\Sigtap\Procedimento;
use App\Services\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentarService;
use App\Services\Geral\AgeService;
use App\Services\Geral\ImcService;
use App\Services\Service;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;

class AtendimentoHistoricoService extends Service
{
    public static function getHistoricoResumido($filters, $options = [])
    {
        $lotacaoLogada = self::getCurrentLotacao();
        $atendimentos = collect();

        self::getPreAtendimentos($filters['paciente_id'])
            ->concat(self::getAtendimentosSoap($filters['paciente_id']))
            ->concat(self::getPosConsultas($filters['paciente_id']))
            ->sortByDesc('data_hora')
            ->each(function ($atendimento) use ($options, $lotacaoLogada, $atendimentos) {
                $atendimento->com_sigilo = false;

                if (!isset($options['format_date_time']) || $options['format_date_time']) {
                    $atendimento->data_hora = $atendimento->data_hora->format('d/m/Y \à\s H:i');
                }

                $parametrizacaoSigilo = ParametrizacaoSigilo::where('ocupacao_id', $atendimento->lotacao['ocupacao']['id'])
                    ->get();

                if (sizeof($parametrizacaoSigilo) > 0) {
                    if ($parametrizacaoSigilo->contains('infraestrutura_id', $atendimento->centro_custo['infraestrutura']['id'])) {
                        $parametrizacaoSigilo = $parametrizacaoSigilo->where('infraestrutura_id', $atendimento->centro_custo['infraestrutura']['id'])->first();
                    } else {
                        $parametrizacaoSigilo = $parametrizacaoSigilo->whereNull('infraestrutura_id')->first();
                    }

                    if (!is_null($parametrizacaoSigilo)) {
                        $permiteVisualizar =
                            $parametrizacaoSigilo->infraestruturas()->where('infraestrutura_id', $lotacaoLogada->infraestrutura_id)->exists() ||
                            $parametrizacaoSigilo->ocupacoes()->where('ocupacao_id', $lotacaoLogada->ocupacao_id)->exists();

                        if (!$permiteVisualizar) {
                            if ($parametrizacaoSigilo->sigilo_tipo_id === SigiloTipo::SIGILO_COMPLETO) {
                                return true;
                            }

                            $atendimento->com_sigilo = true;
                        }
                    }
                }

                $atendimentos->push($atendimento);
            });

        return $atendimentos;
    }

    public static function getHistoricoErpsaudeResumido($paciente)
    {
        $cpf = $paciente->cidadao->cpf ?? null;
        $cns = $paciente->cidadao->cns ?? null;
        $nome = $paciente->cidadao->nome ?? null;
        $dataNascimento = $paciente->cidadao->data_nascimento
            ? $paciente->cidadao->data_nascimento->format('Y-m-d') : null;

        if (empty($cns) && (empty($nome) || empty($dataNascimento))) {
            return [];
        }

        $queryBase = DB::table('integracao_erpsaude_atendimento')
            ->select([
                'integracao_erpsaude_atendimento.id',
                DB::raw("DATE_FORMAT(integracao_erpsaude_atendimento.data_atendimento, '%d/%m/%Y') as data_atendimento"),
                DB::raw("DATE_FORMAT(integracao_erpsaude_atendimento.horario_atendimento, '%H:%i') as horario_atendimento"),
                'integracao_erpsaude_atendimento.profissional',
                'integracao_erpsaude_atendimento.unidade_atendimento',
            ])
            ->join('integracao_erpsaude_paciente', 'integracao_erpsaude_paciente.id', 'integracao_erpsaude_atendimento.paciente_id');

        $result = collect();

        if (!empty($cpf)) {
            $result = (clone $queryBase)
                ->where('integracao_erpsaude_paciente.cpf', $cpf)
                ->orderByDesc('data')
                ->orderByDesc('hora')
                ->get();
        }

        if ($result->isEmpty() && !empty($cns)) {
            $result = (clone $queryBase)
                ->where('integracao_erpsaude_paciente.cns', $cns)
                ->orderByDesc('data')
                ->orderByDesc('hora')
                ->get();
        }

        if ($result->isEmpty() && !empty($nome) && !empty($dataNascimento)) {

            $result = (clone $queryBase)
                ->where('integracao_erpsaude_paciente.nome', $nome)
                ->whereDate('integracao_erpsaude_paciente.data_nascimento', $dataNascimento)
                ->orderByDesc('data')
                ->orderByDesc('hora')
                ->get();
        }

        return $result;
    }

    private static function getPreAtendimentos($pacienteId)
    {
        return DB::table('ambulatorio_atendimento_pre_atendimento')
            ->select([
                'ambulatorio_atendimento_pre_atendimento.id',
                'ambulatorio_atendimento_pre_atendimento.atendimento_id',
                'ambulatorio_atendimento_pre_atendimento.created_at',
                'ocupacao.id AS ocupacao_id',
                'ocupacao.codigo AS ocupacao_codigo',
                'ocupacao.nome AS ocupacao_nome',
                'cadastro_cidadao.nome AS cidadao_nome',
                'cadastro_setor.nome AS setor_nome',
                'cadastro_centro_custo.infraestrutura_id AS centro_custo_infraestrutura_id',
                'cadastro_unidade.nome_fantasia AS unidade_nome_fantasia',
                DB::raw("'Agendada' AS tipo_atendimento"),
            ])
            ->join('ambulatorio_atendimento', 'ambulatorio_atendimento.id', 'ambulatorio_atendimento_pre_atendimento.atendimento_id')
            ->join('ambulatorio_agendamento', 'ambulatorio_agendamento.id', 'ambulatorio_atendimento.agendamento_id')
            ->join('cadastro_lotacao', 'cadastro_lotacao.id', 'ambulatorio_atendimento_pre_atendimento.created_lotacao_id')
            ->join('cadastro_usuario', 'cadastro_usuario.id', 'cadastro_lotacao.usuario_id')
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->join('sigtap.ocupacao', 'ocupacao.id', 'cadastro_lotacao.ocupacao_id')
            ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'ambulatorio_atendimento_pre_atendimento.created_centro_custo_id')
            ->join('cadastro_setor', 'cadastro_setor.id', 'cadastro_centro_custo.setor_id')
            ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'cadastro_centro_custo.infraestrutura_id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'cadastro_infraestrutura.unidade_id')
            ->where('ambulatorio_agendamento.paciente_id', $pacienteId)
            ->unionAll(
                DB::table('ambulatorio_atendimento_pre_atendimento')
                    ->select([
                        'ambulatorio_atendimento_pre_atendimento.id',
                        'ambulatorio_atendimento_pre_atendimento.atendimento_id',
                        'ambulatorio_atendimento_pre_atendimento.created_at',
                        'ocupacao.id AS ocupacao_id',
                        'ocupacao.codigo AS ocupacao_codigo',
                        'ocupacao.nome AS ocupacao_nome',
                        'cadastro_cidadao.nome AS cidadao_nome',
                        'cadastro_setor.nome AS setor_nome',
                        'cadastro_centro_custo.infraestrutura_id AS centro_custo_infraestrutura_id',
                        'cadastro_unidade.nome_fantasia AS unidade_nome_fantasia',
                        DB::raw("'Demanda espontânea' AS tipo_atendimento"),
                    ])
                    ->join('ambulatorio_atendimento', 'ambulatorio_atendimento.id', 'ambulatorio_atendimento_pre_atendimento.atendimento_id')
                    ->join('ambulatorio_demanda_espontanea', 'ambulatorio_demanda_espontanea.id', 'ambulatorio_atendimento.demanda_espontanea_id')
                    ->join('cadastro_lotacao', 'cadastro_lotacao.id', 'ambulatorio_atendimento_pre_atendimento.created_lotacao_id')
                    ->join('cadastro_usuario', 'cadastro_usuario.id', 'cadastro_lotacao.usuario_id')
                    ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
                    ->join('sigtap.ocupacao', 'ocupacao.id', 'cadastro_lotacao.ocupacao_id')
                    ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'ambulatorio_atendimento_pre_atendimento.created_centro_custo_id')
                    ->join('cadastro_setor', 'cadastro_setor.id', 'cadastro_centro_custo.setor_id')
                    ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'cadastro_centro_custo.infraestrutura_id')
                    ->join('cadastro_unidade', 'cadastro_unidade.id', 'cadastro_infraestrutura.unidade_id')
                    ->where('ambulatorio_demanda_espontanea.paciente_id', $pacienteId)
            )
            ->get()
            ->map(function ($preAtendimento) {
                $preAtendimento->created_at = Carbon::create($preAtendimento->created_at);

                $preAtendimento->createdLotacao = (object) [
                    'ocupacao' => (object) [
                        'id' => $preAtendimento->ocupacao_id,
                        'codigo' => $preAtendimento->ocupacao_codigo,
                        'nome' => $preAtendimento->ocupacao_nome,
                    ],
                    'usuario' => (object) [
                        'cidadao' => (object) [
                            'nome' => $preAtendimento->cidadao_nome,
                        ],
                    ],
                ];

                $preAtendimento->createdCentroCusto = (object) [
                    'infraestrutura_id' => $preAtendimento->centro_custo_infraestrutura_id,
                    'setor' => (object) [
                        'nome' => $preAtendimento->setor_nome
                    ],
                    'unidade' => (object) [
                        'nome_fantasia' => $preAtendimento->unidade_nome_fantasia
                    ],
                ];


                return (object) array_merge(self::getLogData($preAtendimento, 'pre-atendimento'), [
                    'id' => $preAtendimento->id,
                    'atendimento_id' => $preAtendimento->atendimento_id,
                    'is_atendimento_soap_assinado' => false,
                ]);
            });
    }

    public static function getPreAtendimento($preAtendimentoId)
    {
        $preAtendimento = AtendimentoPreAtendimento::findOrFail($preAtendimentoId);

        return array_merge(self::getLogData($preAtendimento, 'pre-atendimento'), [
            'ciap' => self::getPreAtendimentoCiap($preAtendimento),
            'motivo_atendimento' => $preAtendimento->motivo_atendimento,
            'classificacao_risco' => self::getPreAtendimentoClassificacaoRisco($preAtendimento),
            'antropometria' => self::getPreAtendimentoAntropometria($preAtendimento),
            'sinal_vital' => self::getPreAtendimentoSinalVital($preAtendimento),
            'glicemia_capilar' => self::getPreAtendimentoGlicemiaCapilar($preAtendimento),
            'declaracao_comparecimento' => self::getPreAtendimentoDeclaracaoComparecimento($preAtendimento),
            'procedimentos' => self::getPreAtendimentoProcedimentos($preAtendimento),
            'medicamentos' => self::getPreAtendimentoMedicamentos($preAtendimento),
            'desfecho' => self::getPreAtendimentoDesfecho($preAtendimento),
        ]);
    }

    private static function getPreAtendimentoCiap($preAtendimento)
    {
        return $preAtendimento->ciap()->first(['codigo', 'descricao']);
    }

    private static function getPreAtendimentoClassificacaoRisco($preAtendimento)
    {
        return $preAtendimento->classificacaoRisco()->first(['nome']);
    }

    private static function getPreAtendimentoAntropometria($preAtendimento)
    {
        $antropometria = $preAtendimento->antropometria()->first([
            'peso',
            'altura',
            'perimetro_cefalico',
            'circunferencia_abdominal',
            'perimetro_panturrilha',
        ]);

        if (!is_null($antropometria)) {

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

        return $antropometria;
    }

    private static function getPreAtendimentoSinalVital($preAtendimento)
    {
        return $preAtendimento->sinalVital()->first([
            'pressao_arterial',
            'frequencia_respiratoria',
            'frequencia_cardiaca',
            'temperatura',
            'saturacao_o2',
        ]);
    }

    private static function getPreAtendimentoGlicemiaCapilar($preAtendimento)
    {
        $glicemiaCapilar = $preAtendimento->glicemiaCapilar()
            ->with('momentoColeta:id,nome')
            ->first(['momento_coleta_id', 'valor']);

        if (!is_null($glicemiaCapilar)) {

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

        return $glicemiaCapilar;
    }

    private static function getPreAtendimentoDeclaracaoComparecimento($preAtendimento)
    {
        $declaracaoComparecimento = $preAtendimento->declaracaoComparecimento()
            ->with('turno:id,nome')
            ->first([
                'nome_acompanhante',
                'motivo_comparecimento',
                'turno_id',
                'entrada',
                'saida',
            ]);

        if (!is_null($declaracaoComparecimento)) {

            $declaracaoComparecimento->makeHidden('turno_id');

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

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

        return $declaracaoComparecimento;
    }

    private static function getPreAtendimentoProcedimentos($preAtendimento)
    {
        $procedimentos = $preAtendimento->procedimentos()
            ->get([
                'procedimento_id',
                'quantidade',
                'automatico',
                'local_curativo',
                'saida_item_id',
            ]);

        $procedimentos->each(function ($procedimento) {

            $almoxarifadoSaidaItem = $procedimento->almoxarifadoSaidaItem;

            $procedimento->procedimento = self::getProcedimento($procedimento->procedimento_id);

            $procedimento->makeHidden('procedimento_id');

            $procedimento->material_descricao_completa = $almoxarifadoSaidaItem->material->descricaoCompleta ?? null;
            $procedimento->material_quantidade = $almoxarifadoSaidaItem->quantidade ?? null;
        });

        return $procedimentos;
    }

    private static function getPreAtendimentoMedicamentos($preAtendimento)
    {
        $medicamentos = $preAtendimento->medicamentos()
            ->get([
                'saida_item_id',
            ]);

        $medicamentos->each(function ($medicamento) {

            $almoxarifadoSaidaItem = $medicamento->almoxarifadoSaidaItem;

            $medicamento->descricao_completa = $almoxarifadoSaidaItem->material->descricaoCompleta ?? null;
            $medicamento->quantidade = $almoxarifadoSaidaItem->quantidade ?? null;
        });

        return $medicamentos;
    }

    private static function getPreAtendimentoDesfecho($preAtendimento)
    {
        return $preAtendimento->paciente_liberado
            ? Desfecho::PACIENTE_LIBERADO
            : ($preAtendimento->paciente_mantido_fila ? Desfecho::MANTER_NA_FILA : Desfecho::PACIENTE_ENCAMINHADO);
    }

    private static function getAtendimentosSoap($pacienteId)
    {
        return DB::table('ambulatorio_atendimento_soap')
            ->select([
                'ambulatorio_atendimento_soap.id',
                'ambulatorio_atendimento_soap.atendimento_id',
                'jornada.data',
                'ambulatorio_atendimento_soap.is_atendimento_enfermagem',
                'ambulatorio_atendimento_soap.is_atendimento_soap_assinado',
                'ocupacao.id AS ocupacao_id',
                'ocupacao.codigo AS ocupacao_codigo',
                'ocupacao.nome AS ocupacao_nome',
                'cadastro_cidadao.nome AS cidadao_nome',
                'cadastro_setor.nome AS setor_nome',
                'cadastro_centro_custo.infraestrutura_id AS centro_custo_infraestrutura_id',
                'cadastro_unidade.nome_fantasia AS unidade_nome_fantasia',
                DB::raw("'Agendada' AS tipo_atendimento"),
            ])
            ->join('ambulatorio_atendimento', 'ambulatorio_atendimento.id', 'ambulatorio_atendimento_soap.atendimento_id')
            ->join('ambulatorio_agendamento', 'ambulatorio_agendamento.id', 'ambulatorio_atendimento.agendamento_id')
            ->join('ambulatorio_jornada as jornada', 'jornada.id', 'ambulatorio_agendamento.jornada_id')
            ->join('cadastro_lotacao', function ($join) {
                $join->whereRaw("
                    (
                        (ambulatorio_atendimento_soap.is_atendimento_enfermagem = true
                            AND cadastro_lotacao.id = ambulatorio_atendimento_soap.created_lotacao_id)
                        OR
                        (ambulatorio_atendimento_soap.is_atendimento_enfermagem = false
                            AND cadastro_lotacao.id = jornada.lotacao_id)
                    )
                ");
            })
            ->join('cadastro_usuario', 'cadastro_usuario.id', 'cadastro_lotacao.usuario_id')
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->join('sigtap.ocupacao', 'ocupacao.id', 'cadastro_lotacao.ocupacao_id')
            ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'ambulatorio_atendimento_soap.created_centro_custo_id')
            ->join('cadastro_setor', 'cadastro_setor.id', 'cadastro_centro_custo.setor_id')
            ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'cadastro_centro_custo.infraestrutura_id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'cadastro_infraestrutura.unidade_id')
            ->where('ambulatorio_atendimento_soap.is_rascunho', false)
            ->where('ambulatorio_agendamento.paciente_id', $pacienteId)
            ->unionAll(
                DB::table('ambulatorio_atendimento_soap')
                    ->select([
                        'ambulatorio_atendimento_soap.id',
                        'ambulatorio_atendimento_soap.atendimento_id',
                        'ambulatorio_demanda_espontanea.data',
                        'ambulatorio_atendimento_soap.is_atendimento_enfermagem',
                        'ambulatorio_atendimento_soap.is_atendimento_soap_assinado',
                        'ocupacao.id AS ocupacao_id',
                        'ocupacao.codigo AS ocupacao_codigo',
                        'ocupacao.nome AS ocupacao_nome',
                        'cadastro_cidadao.nome AS cidadao_nome',
                        'cadastro_setor.nome AS setor_nome',
                        'cadastro_centro_custo.infraestrutura_id AS centro_custo_infraestrutura_id',
                        'cadastro_unidade.nome_fantasia AS unidade_nome_fantasia',
                        DB::raw("'Demanda espontânea' AS tipo_atendimento"),
                    ])
                    ->join('ambulatorio_atendimento', 'ambulatorio_atendimento.id', 'ambulatorio_atendimento_soap.atendimento_id')
                    ->join('ambulatorio_demanda_espontanea', 'ambulatorio_demanda_espontanea.id', 'ambulatorio_atendimento.demanda_espontanea_id')
                    ->join('cadastro_lotacao', 'cadastro_lotacao.id', 'ambulatorio_atendimento_soap.created_lotacao_id')
                    ->join('cadastro_usuario', 'cadastro_usuario.id', 'cadastro_lotacao.usuario_id')
                    ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
                    ->join('sigtap.ocupacao', 'ocupacao.id', 'cadastro_lotacao.ocupacao_id')
                    ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'ambulatorio_atendimento_soap.created_centro_custo_id')
                    ->join('cadastro_setor', 'cadastro_setor.id', 'cadastro_centro_custo.setor_id')
                    ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'cadastro_centro_custo.infraestrutura_id')
                    ->join('cadastro_unidade', 'cadastro_unidade.id', 'cadastro_infraestrutura.unidade_id')
                    ->where('ambulatorio_atendimento_soap.is_rascunho', false)
                    ->where('ambulatorio_demanda_espontanea.paciente_id', $pacienteId)
            )
            ->get()
            ->map(function ($soap) {
                $soap->created_at = Carbon::create($soap->data);

                $soap->createdLotacao = (object) [
                    'ocupacao' => (object) [
                        'id' => $soap->ocupacao_id,
                        'codigo' => $soap->ocupacao_codigo,
                        'nome' => $soap->ocupacao_nome,
                    ],
                    'usuario' => (object) [
                        'cidadao' => (object) [
                            'nome' => $soap->cidadao_nome,
                        ],
                    ],
                ];

                $soap->createdCentroCusto = (object) [
                    'infraestrutura_id' => $soap->centro_custo_infraestrutura_id,
                    'setor' => (object) [
                        'nome' => $soap->setor_nome
                    ],
                    'unidade' => (object) [
                        'nome_fantasia' => $soap->unidade_nome_fantasia
                    ],
                ];

                $soap->tipo_atendimento = $soap->tipo_atendimento;

                return (object) array_merge(self::getLogData($soap, 'atendimento'), [
                    'id' => $soap->id,
                    'atendimento_id' => $soap->atendimento_id,
                    'is_atendimento_enfermagem' => (bool) $soap->is_atendimento_enfermagem,
                    'is_atendimento_soap_assinado' => (bool) $soap->is_atendimento_soap_assinado,
                ]);
            });
    }

    public static function getAtendimentoSoap($soapId)
    {
        $soap = AtendimentoSoap::findOrFail($soapId);

        $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;
        }
        return array_merge(self::getLogData($soap, 'atendimento'), [
            'tempo_atendimento_unidade' => self::getTempoAtendimentoUnidade($soap),
            'tempo_atendimento' => $soap->tempo_atendimento,
            'sexo_id' => $soap->atendimento->paciente->cidadao->sexo_id,
            '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,
            'antecedente' => self::getAtendimentoAntecedente($soap),
            'subjetivo' => [
                'descricao' => $soap->subjetivo_descricao,
                'motivos' => self::getAtendimentoMotivos($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),
                'tria' => self::getAtendimentoObjetivoTria($soap),
                'marcador_consumo_alimentar' => self::getAtendimentoMarcadorConsumoAlimentar($soap),
                'vacinacao_em_dia' => $soap->vacinacao_em_dia,
                'paciente_com_necessidade_especial' => $soap->paciente_com_necessidade_especial,
                'resultados_exames' => self::getAtendimentoResultadosExames($soap),
                'exames_avaliados' =>self::getAtendimentoExamesAvaliados($soap->atendimento),
                'triagens_neonatal' => self::getAtendimentoTriagensNeoNatal($soap->atendimento),
            ],
            '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),
                'condicoes_emad' => self::getAtendimentoCondicoesEmad($soap),
            ],
            'plano' => [
                'descricao' => $soap->plano_descricao,
                'intervencoes' => self::getAtendimentoIntervencoes($soap),
                'procedimentos_clinicos' => self::getAtendimentoProcedimentosClinicos($soap),
                'procedimentos_emad' => self::getAtendimentoProcedimentosEmad($soap),
                'prescricoes_medicamentos' => self::getAtendimentoPrescricoesMedicamentos($soap),
                'solicitacoes_exames_comuns' => self::getAtendimentoSolicitacoesExamesComuns($soap),
                'exames_solicitados' =>self::getAtendimentoExamesSolicitados($soap),
                'triagens_neonatal_solicitados' =>self::getAtendimentoTriagensNeonatalSolicitados($soap),
                'solicitacoes_exames_alto_custo' => self::getAtendimentoSolicitacoesExamesAltoCusto($soap),
                'testes_rapidos' => self::getAtendimentoTestesRapidos($soap),
                'atestados' => self::getAtendimentoAtestados($soap),
                'declaracoes_comparecimento' => self::getAtendimentoDeclaracoesComparecimento($soap),
                'cartas_medicas' => self::getAtendimentoCartasMedicas($soap),
                'orientacoes' => self::getAtendimentoOrientacoes($soap),
                'encaminhamentos' => self::getAtendimentoEncaminhamentos($soap),
                'compartilhamentos_cuidado' => self::getAtendimentoCompartilhamentosCuidado($soap),
                'feridas' => self::getFeridas($soap),
            ],
            'finalizacao' => [
                'atendimento_tipo' => self::getAtendimentoAtendimentoTipo($soap),
                'atendimento_compartilhado_usuario' => self::getAtendimentoAtendimentoCompartilhadoUsuario($soap),
                'procedimentos_administrativos' => self::getAtendimentoProcedimentosAdministrativos($soap),
                'casos_suspeitos' => self::getAtendimentoCasosSuspeitos($soap),
                'racionalidade_saude' => self::getAtendimentoRacionalidadeSaude($soap),
                'condutas' => self::getAtendimentoCondutas($soap),
                'equipe' => self::getAtendimentoEquipe($soap),
                'turno' => self::getAtendimentoTurno($soap),
                'atencao_basica_local_atendimento' => self::getAtendimentoAtencaoBasicaLocalAtendimento($soap),
                'desfecho' => $soap->paciente_liberado ? Desfecho::PACIENTE_LIBERADO : Desfecho::MANTER_NA_FILA,
                '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,
            ],
            'pre_natal' => [
                'is_primeiro_atendimento' => self::isPrimeiroAtendimentoPreNatal($soap),
                '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,
                'gravidez_planejada' => $soap->pre_natal_gravidez_planejada,
                'batimento_cardiaco_fetal' => $soap->pre_natal_batimento_cardiaco_fetal,
                'dpp' => $soap->dum ? $soap->dum->copy()->addMonths(9)->addDays(7)->format('d/m/Y') : null,
                'desfecho_em' => $soap->pre_natal_desfecho_em ? $soap->pre_natal_desfecho_em->format('d/m/Y') : null,
            ],
            'puericultura' => [
                'is_primeiro_atendimento' => self::isPrimeiroAtendimentoPuericultura($soap),
                'is_crianca_aleitamento' => $idadeAnos <= AtendimentoService::IDADE_ANOS_FINAL_CRIANCA_ALEITAMENTO,
                'gravidez_tipo' => self::getAtendimentoPuericulturaGravidezTipo($soap),
                'parto_tipo' => self::getAtendimentoPuericulturaPartoTipo($soap),
                'idade_gestacional_semanas' => $soap->puericultura_idade_gestacional_semanas,
                'idade_gestacional_dias' => $soap->puericultura_idade_gestacional_dias,
                'apgar_primeiro_minuto' => $soap->puericultura_apgar_primeiro_minuto,
                'apgar_quinto_minuto' => $soap->puericultura_apgar_quinto_minuto,
                'apgar_decimo_minuto' => $soap->puericultura_apgar_decimo_minuto,
                'peso' => $soap->puericultura_peso,
                'comprimento' => $soap->puericultura_comprimento,
                'perimetro_cefalico' => $soap->puericultura_perimetro_cefalico,
                'aleitamento_tipo' => self::getAtendimentoPuericulturaAleitamentoTipo($soap),
                'alteracoes_fenotipicas' => self::getAtendimentoPuericulturaAlteracoesFenotipicas($soap),
                'fatores_risco' => self::getAtendimentoPuericulturaFatoresRisco($soap),
                'marcos_desenvolvimento' => self::getAtendimentoPuericulturaMarcosDesenvolvimento($soap),
                'questionario_m_chat_r' => self::getAtendimentoPuericulturaQuestionarioMChatR($soap),
            ],
            '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),
            ],
            'antropometrias' => self::getAtendimentoAntropometrias($soap),
        ]);
    }
    public static function getTempoAtendimentoUnidade($soap){
        $inicio = Carbon::parse($soap->atendimento->created_at);
        $fim = Carbon::parse($soap->atendimento->finalizado_em);

        $diferenca = $inicio->diff($fim);
        
        $tempo = sprintf(
            '%02d:%02d:%02d',
            ($diferenca->days * 24) + $diferenca->h,
            $diferenca->i,
            $diferenca->s
        );
        return $tempo;
    }
    public static function getFeridas($soap)
    {

        $pacienteId = $soap->atendimento->paciente->id;

        $atendimentos = Atendimento::where(function ($q) use ($pacienteId) {

            $q->whereHas('agendamento', function ($sub) use ($pacienteId) {

                $sub->where('paciente_id', $pacienteId);

            })->orWhereHas('demandaEspontanea', function ($sub) use ($pacienteId) {

                $sub->where('paciente_id', $pacienteId);
            });

        })->pluck('id');

        $soaps = AtendimentoSoap::whereIn('atendimento_id', $atendimentos)
            ->with([
                'feridas',
                'feridas.ferida',
                'feridas.localAnatomico',
                'feridas.localAnatomicoRegiao',
                'feridas.exsudato',
                'feridas.necrose',
                'feridas.procedimentos',
                'feridas.procedimentos.atendimentoProcedimento',
                'feridas.procedimentos.atendimentoProcedimento.materiais',
                'feridas.images',
            ])->get();

            $feridas = $soaps->flatMap(function ($soap) {
                return $soap->feridas->map(function ($ferida) {

                    $procedimentos = $ferida->procedimentos->map(function ($item) {
                        $atendimentoProcedimento = $item->atendimentoProcedimento;

                        return [
                            'id' => $item->id,
                            'procedimento_id' => $item->atendimentoProcedimento->procedimento_id,
                            'procedimento' =>  [
                                'id' => $item->atendimentoProcedimento->procedimento->id ?? null,
                                'codigo' => $item->atendimentoProcedimento->procedimento->codigo ?? null,
                                'nome' => $item->atendimentoProcedimento->procedimento->nome ?? null,
                                'materiais' => $atendimentoProcedimento
                                    ? $atendimentoProcedimento->materiais->map(function ($material) {
                                        return [
                                            'id' => $material->almoxarifadoSaidaItem->material->id ?? null,
                                            'descricao_completa' =>$material->almoxarifadoSaidaItem->material->descricaoCompleta ?? null,
                                            'quantidade' => $material->almoxarifadoSaidaItem->quantidade ?? null
                                        ];
                                    }) : collect(),
                            ],
                            'cid' => $item->atendimentoProcedimento->cid ? [
                                'id' => $item->atendimentoProcedimento->cid->id,
                                'codigo' => $item->atendimentoProcedimento->cid->codigo,
                                'nome' => $item->atendimentoProcedimento->cid->nome,
                            ] : null,
                            'quantidade' => $item->atendimentoProcedimento->quantidade ?? null,
                        ];
                    });

                    $imagesBase64 = $ferida->images->map(function ($image) {
                        $arquivo = $image->arquivo;

                        $path = Storage::path('ambulatorio' . DIRECTORY_SEPARATOR . 'feridas' . DIRECTORY_SEPARATOR . app('config')->get('database.default') . DIRECTORY_SEPARATOR . $arquivo);

                        if (file_exists($path)) {
                            $type = pathinfo($path, PATHINFO_EXTENSION);
                            $data = file_get_contents($path);
                            $base64 = 'data:image/' . $type . ';base64,' . base64_encode($data);

                            return [
                                'id' => $image->id,
                                'arquivo' => $base64
                            ];
                        }

                        return [
                            'id' => $image->id,
                            'arquivo' => null
                        ];
                    });

                    return [
                        'id' => $ferida->id,
                        'soap_id' => $ferida->soap_id,
                        'data' => $ferida->data->format('d/m/Y') ?? null,
                        'tipo_descricao' => $ferida->ferida->nome ?? null,
                        'tipo_id' => $ferida->ferida_id,
                        'local_anatomico_descricao' => $ferida->localAnatomico->descricao ?? null,
                        'local_anatomico_id' => $ferida->local_anatomico_id,
                        'local_anatomico_regiao_descricao' => $ferida->localAnatomicoRegiao->descricao ?? null,
                        'local_anatomico_regiao_id' => $ferida->local_anatomico_regiao_id,
                        'exsudato_descricao' => $ferida->exsudato->descricao ?? null,
                        'exsudato_id' => $ferida->ferida_exsudato_id,
                        'necrose_descricao' => $ferida->necrose->descricao ?? null,
                        'necrose_id' => $ferida->ferida_necrose,
                        'cicatrizada' => $ferida->cicatrizada,
                        'comprimento' => $ferida->comprimento,
                        'largura' => $ferida->largura,
                        'profundidade' => $ferida->profundidade,
                        'dor' => $ferida->dor,
                        'observacao' => $ferida->observacao,
                        'procedimentos' => $procedimentos,
                        'images' => $imagesBase64,
                    ];
                });
            });

        return [
            'ferida' => $feridas
        ];
    }

    public static function getAtendimentoHospital($id)
    {

        $atendimento = AtendimentoErpsaude::where('id', $id)->first();

        $cidModel = $atendimento->cid10 ? Cid::where('codigo', $atendimento->cid10)->first() : null;

        $cid = $cidModel
            ? $cidModel->codigo . ' - ' . $cidModel->nome
            : ($atendimento->cid10 ?? '-');

        return [
            'data' => $atendimento->data,
            'hora' => $atendimento->hora,
            'hipotese_diagnostica' => $atendimento->hipotese_diagnostica,
            'cid10' => $cid,
            'descricao_procedimento' => $atendimento->descricao_procedimento,
            'descricao_exame_clinico' => $atendimento->descricao_exame_clinico,
            'conduta_medica' => $atendimento->conduta_medica,
            'codigo_conta_prof' => '',
            'profissional' => $atendimento->profissional,
            'conselho' => $atendimento->conselho,
            'uf_conselho' => $atendimento->uf_conselho,
            'convenio' => $atendimento->convenio,
            'registro_ans' => $atendimento->registro_ans ?? '',
            'cod_convenio' => $atendimento->cod_convenio ?? '',
            'nome_setor' => $atendimento->nome_setor ?? '',
            'codigo_setor' => $atendimento->codigo_setor ?? '',
            'cod_tipo_encaminhamento' => $atendimento->cod_tipo_encaminhamento ?? '',
            'cod_tipo_atendimento' => $atendimento->tipoAtendimento ? $atendimento->tipoAtendimento->codigo : '',
            'cod_grupo_atendimento' => $atendimento->cod_grupo_atendimento ?? '',
            'cod_un_encaminhadora' =>  $atendimento->unidadeEncaminhadora ? $atendimento->unidadeEncaminhadora->codigo : '',
            'cod_un_atendimento' =>  $atendimento->unidadeAtendimento->descricao,
            'data_atendimento' => Carbon::parse($atendimento->data_atendimento)->format('d/m/Y'),
            'data_alta' => $atendimento->data_alta ? Carbon::parse($atendimento->data_alta)->format('d/m/Y') : '',
            'horario_atendimento' => Carbon::parse($atendimento->horario_atendimento)->format('H:i'),
            'hora_alta' => $atendimento->hora_alta ? Carbon::parse($atendimento->hora_alta)->format('H:i') : '',
            'cod_tipo_alta' => $atendimento->tipoAlta->descricao,
            'un_atendimento' => '',
            'cnes_un_atendimento' => $atendimento->cnes_un_atendimento,
            'reavaliacoes' => $atendimento->reavaliacoes->map(function ($reavaliacao) {
                return [
                    'reavaliacao' => $reavaliacao->reavaliacao ?? '-',
                    'profissional' => $reavaliacao->profissional ?? '',
                    'num_conselho' => $reavaliacao->numero_conselho ?? '',
                    'uf_conselho' => $reavaliacao->uf_conselho ?? '',
                    'data_reavaliacao' => $reavaliacao->data ? Carbon::parse($reavaliacao->data)->format('d/m/Y') : '',
                    'hora_reavaliacao' => $reavaliacao->hora ? Carbon::parse($reavaliacao->hora)->format('H:i') : '',
                ];
            })->toArray(),
            'exames' => $atendimento->exames->map(function ($exame) {
                return [
                    'tipo' => $exame->tipo ?? '',
                    'descricao' => $exame->exame ?? '',
                ];
            })->toArray(),
            'medicamentos' => $atendimento->medicamentos->map(function ($medicamento) {
                return [
                    'medicamento' => $medicamento->medicamento ?? '',
                    'qtde_presc' => $medicamento->quantidade ?? '',
                    'uni_med_presc' => $medicamento->unidade_medida ?? '',
                    'tipo' => $medicamento->tipo ? strtoupper($medicamento->tipo) : '',
                    'id_medicamento' => $medicamento->id ?? '0',
                ];
            })->toArray(),
        ];
    }

    private static function isPrimeiroAtendimentoPuericultura($soap)
    {
        if (!$soap->is_atendimento_puericultura) {

            return false;
        }

        $primeiroSoapPuericultura = AtendimentoSoap::where('is_rascunho', false)
            ->whereHas('atendimento', fn ($q) => $q
                ->whereHas('agendamento', fn ($q) => $q
                    ->where('paciente_id', $soap->atendimento->paciente->id)
                )
                ->orWhereHas('demandaEspontanea', fn ($q) => $q
                    ->where('paciente_id', $soap->atendimento->paciente->id)
                )
            )
            ->where('is_atendimento_puericultura', true)
            ->orderBy('created_at')
            ->first(['id']);

        return $soap->id === $primeiroSoapPuericultura->id;
    }

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

            return false;
        }

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

        if (!$problemaCondicaoGravidez) {

            return false;
        }

        $primeiroProblemaCondicaoGravidez = AtendimentoSoapProblemaCondicao::whereHas('soap', fn ($q) => $q
                ->where('is_rascunho', false)
            )
            ->where(
                'paciente_gestacao_id',
                $problemaCondicaoGravidez->paciente_gestacao_id
            )
            ->orderBy('created_at')
            ->first(['id']);

        if (!$primeiroProblemaCondicaoGravidez) {

            return false;
        }

        return $problemaCondicaoGravidez->id === $primeiroProblemaCondicaoGravidez->id;
    }

    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 getAtendimentoEquipe($soap)
    {
        $equipe = $soap->equipe()
            ->with([
                'area:id,numero_ine,descricao',
                'microarea:id,descricao',
            ])
            ->first(['area_id', 'microarea_id']);

        return (object) [
            'descricao' => is_null($equipe)
                ? null
                : ("INE: {$equipe->area->numero_ine} - Área: {$equipe->area->descricao}"
                    . (is_null($equipe->microarea_id) ? '' : " - Microárea: {$equipe->microarea->descricao}")
                ),
        ];
    }

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

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

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

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

    private static function getAtendimentoAtendimentoTipo($soap)
    {
        $nome = null;

        if ($soap->atendimento_tipo_id === TipoAtendimento::CONSULTA_NO_DIA) {

            $nome = 'Atendimento no dia';
        }
        if ($soap->atendimento_tipo_id === TipoAtendimento::ATENDIMENTO_DE_URGENCIA) {

            $nome = 'Urgência';
        }

        return (object) ['nome' => $nome];
    }

    private static function getAtendimentoAtendimentoCompartilhadoUsuario($soap)
    {
        $usuario = $soap->atendimentoCompartilhadoUsuario()->setEagerLoads([])->first(['cidadao_id']);

        if (!is_null($usuario)) {

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

            $usuario = (object) [
                'nome' => $cidadao->nome,
                'cns' => MaskUtil::getCnsMasked($cidadao->cns),
            ];
        }

        return $usuario;
    }

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

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

    private static function getAtendimentoCasosSuspeitos($soap)
    {
        return $soap->casosSuspeitos()->orderBy('nome')->get(['nome']);
    }

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

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

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

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

    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 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 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()->latest('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']);

        if (is_null($marcadorConsumoAlimentar)) {

            return null;
        }

        $marcador = MarcadorConsumoAlimentarService::edit($marcadorConsumoAlimentar->id);

        return [
            'titulo' => $marcador['form']['titulo'],
            'titulo_area' => $marcador['form']['titulo_area'],
            'perguntas' => $marcador['form']['perguntas'],
            'respostas' => $marcador['model']['perguntas'],
        ];
    }

    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, 'atendimento'), [
                '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([
                        'descricao' => "{$codigo} - {$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,
            '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 getAtendimentoPuericulturaGravidezTipo($soap)
    {
        return $soap->puericulturaGravidezTipo()->first(['nome']);
    }

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

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

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

            $resposta = (object) ['is_presente' => null, 'status' => 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;

                $resposta->status = is_null($alteracao->is_presente)
                    ? null
                    :  (($alteracao->is_presente ? 'Presente em ' : 'Ausente em ')
                        . $alteracao->created_at->format('d/m/Y'));
            }

            return $resposta;
        };

        return PuericulturaAlteracaoFenotipica::orderBy('id')->get()->map(function ($alteracao) use ($getResposta) {

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

            return [
                'id' => $alteracao->id,
                'descricao' => $alteracao->descricao,
                'is_presente' => $resposta->is_presente,
                'status' => $resposta->status,
            ];
        });
    }

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

            $resposta = (object) ['is_presente' => null, 'status' => 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;

                $resposta->status = is_null($fator->is_presente)
                    ? null
                    : (($fator->is_presente ? 'Presente em ' : 'Ausente em ')
                        . $fator->created_at->format('d/m/Y'));
            }

            return $resposta;
        };

        return PuericulturaFatorRisco::orderBy('id')->get()->map(function ($fator) use ($getResposta) {

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

            return [
                'id' => $fator->id,
                'descricao' => $fator->descricao,
                'is_presente' => $resposta->is_presente,
                'status' => $resposta->status,
            ];
        });
    }

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

        if (is_null($dataNascimento)) {

            return [];
        }

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

            $resposta = (object) [
                'is_presente' => null,
                'status' => 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;

                        $resposta->status = $dataNascimento->copy()
                            ->addYears($resposta->alcancado_com_anos)
                            ->addMonths($resposta->alcancado_com_meses)
                            ->format('d/m/Y');
                    }
                    else {

                        $resposta->alcancado_com_anos = null;
                        $resposta->alcancado_com_meses = null;
                        $resposta->status = $marco->created_at->format('d/m/Y');
                    }
                }
                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;

                    $resposta->status = $dataNascimento->copy()
                        ->addYears($resposta->alcancado_com_anos)
                        ->addMonths($resposta->alcancado_com_meses)
                        ->format('d/m/Y');
                }
            }

            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,
                        'status' => $resposta->status,
                        'alcancado_com_anos' => $resposta->alcancado_com_anos,
                        'alcancado_com_meses' => $resposta->alcancado_com_meses,
                    ]);
                }
            });

        $marcos->each(function ($marco) {

            $marco->perguntas->each(function ($pergunta) use ($marco) {

                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
                    ) {

                        $pergunta->status = "Presente com atraso em {$pergunta->status}";
                    }
                    else {

                        $pergunta->status = ($pergunta->is_presente ? 'Presente em ' : 'Ausente em ')
                            . $pergunta->status;
                    }
                }
            });
        });

        return $marcos;
    }

    private static function getAtendimentoAntropometrias($soap)
    {
        return $soap->antropometrias()
            ->whereDoesntHave('soapObjetivoAntropometria')
            ->orderBy('medido_em')
            ->get([
                'medido_em',
                'peso',
                'altura',
                'perimetro_cefalico',
                'circunferencia_abdominal',
                'perimetro_panturrilha',
            ]);
    }

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

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

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

        return $motivos;
    }

    private static function getAtendimentoExamesAvaliados($atendimento)
    {
        return DB::table('ambulatorio_atendimento_soap_exame_avaliado as pivot')
            ->join('ambulatorio_atendimento_soap as soap', 'soap.id', 'pivot.soap_id')
            ->join('atencao_basica_cadastro_exame_solicitado_avaliado as exame_avaliado', 'exame_avaliado.id', 'pivot.exame_solicitado_avaliado_id')
            ->where('soap.is_rascunho', false)
            ->where('soap.atendimento_id', $atendimento->id)
            ->select(DB::raw("
                exame_avaliado.id,
                exame_avaliado.descricao,
                exame_avaliado.codigo_procedimento,
                DATE_FORMAT(pivot.solicitado_em, '%d/%m/%Y') as solicitado_em,
                DATE_FORMAT(pivot.realizado_em, '%d/%m/%Y') as realizado_em,
                DATE_FORMAT(pivot.resultado_em, '%d/%m/%Y') as resultado_em,
                pivot.resultado
            "))
            ->orderBy('descricao')
            ->get();
    }

    private static function getAtendimentoExamesSolicitados($soap)
    {
        return AtendimentoSoapExameSolicitado::where('soap_id', $soap->id)
            ->get()
            ->map(function ($solicitacao) {

                return [
                    'cid_descricao' => is_null($solicitacao->cid_id)
                        ? null : "{$solicitacao->cid->codigo} - {$solicitacao->cid->nome}",
                    'ciap_descricao' => is_null($solicitacao->ciap_id)
                        ? null : "{$solicitacao->ciap->codigo} - {$solicitacao->ciap->descricao}",
                    'justificativa' => $solicitacao->justificativa,
                    'observacao' => $solicitacao->observacao,
                    'exames' => $solicitacao->examesSolicitados->map(function ($item) {
                        return [
                            'id' => $item->id,
                            'descricao' => $item->descricao,
                            'codigo_procedimento' => $item->codigo_procedimento,
                        ];
                    }),
                ];
            });
    }

    private static function getAtendimentoTriagensNeonatalSolicitados($soap)
    {
        return AtendimentoSoapTriagemNeonatalSolicitado::where('soap_id', $soap->id)
            ->get()
            ->map(function ($solicitacao) {

                return [
                    'cid_descricao' => is_null($solicitacao->cid_id)
                        ? null : "{$solicitacao->cid->codigo} - {$solicitacao->cid->nome}",
                    'ciap_descricao' => is_null($solicitacao->ciap_id)
                        ? null : "{$solicitacao->ciap->codigo} - {$solicitacao->ciap->descricao}",
                    'justificativa' => $solicitacao->justificativa,
                    'observacao' => $solicitacao->observacao,
                    'exames' => $solicitacao->triagensNeonatalSolicitados->map(function ($item) {
                        return [
                            'id' => $item->id,
                            'descricao' => $item->descricao,
                            'codigo_procedimento' => $item->codigo_procedimento,
                        ];
                    }),
                ];
            });
    }

    private static function getAtendimentoTriagensNeoNatal($atendimento)
    {
        return DB::table('ambulatorio_atendimento_soap_triagem_neonatal as pivot')
            ->join('ambulatorio_atendimento_soap as soap', 'soap.id', 'pivot.soap_id')
            ->join('atencao_basica_cadastro_triagem_neonatal as triagem_neonatal', 'triagem_neonatal.id', 'pivot.triagem_neonatal_id')
            ->where('soap.is_rascunho', false)
            ->where('soap.atendimento_id', $atendimento->id)
            ->select(DB::raw("
                triagem_neonatal.id,
                triagem_neonatal.descricao,
                triagem_neonatal.codigo_procedimento,
                DATE_FORMAT(pivot.solicitado_em, '%d/%m/%Y') as solicitado_em,
                DATE_FORMAT(pivot.realizado_em, '%d/%m/%Y') as realizado_em,
                DATE_FORMAT(pivot.resultado_em, '%d/%m/%Y') as resultado_em,
                pivot.resultado
            "))
            ->orderBy('descricao')
            ->get();
    }

    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',
            ]);

        $resultadosExames->each(function ($resultadoExame) {

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

            $resultadoExame->makeHidden(['exame_id', 'resultado_tipo_id']);

            if (!is_null($resultadoExame->resultadoTipo)) {

                $resultadoExame->resultadoTipo->makeHidden('id');
            }
        });

        return $resultadosExames;
    }

    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 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 getAtendimentoDeclaracoesComparecimento($soap)
    {
        $declaracoesComparecimento = $soap->declaracoesComparecimento()
            ->with('turno:id,nome')
            ->get([
                'motivo_comparecimento',
                '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 getAtendimentoProcedimentosClinicos($soap)
    {
        $feridaProcedimentosIds = $soap->feridas()
            ->with('procedimentos')
            ->get()
            ->flatMap(function ($ferida) {
                return $ferida->procedimentos->pluck('atendimento_procedimento_id');
            })
            ->toArray();

        return $soap->procedimentosClinicos()
            ->whereNotIn('atendimento_procedimento_id', $feridaProcedimentosIds)
            ->get([
                'atendimento_procedimento_id',
                'observacao',
            ])
            ->map(function ($procedimentoClinico) {

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

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

    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',
                ]);

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

    private static function getAtendimentoSolicitacoesExamesComuns($soap)
    {
        return self::getAtendimentoSolicitacoesExames($soap, false);
    }

    private static function getAtendimentoSolicitacoesExamesAltoCusto($soap)
    {
        return self::getAtendimentoSolicitacoesExames($soap, true);
    }

    private static function getAtendimentoSolicitacoesExames($soap, $isAltoCusto)
    {
        $solicitacoesExames = $soap->solicitacoesExames()
            ->with([
                'cid:id,codigo,nome',
                'ciap:id,codigo,descricao',
                'classificacaoRisco:id,descricao_encaminhamento',
                'itens:solicitacao_exame_id,exame_id',
            ])
            ->where('alto_custo', $isAltoCusto)
            ->get([
                'id',
                'cid_id',
                'ciap_id',
                'classificacao_risco_id',
                'justificativa',
                'observacao',
            ]);

        $solicitacoesExames->each(function ($solicitacaoExame) {

            $solicitacaoExame->makeHidden(['id', 'cid_id', 'classificacao_risco_id']);

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

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

            if (!is_null($solicitacaoExame->classificacaoRisco)) {

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

            $solicitacaoExame->itens->each(function ($item) {

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

                $item->makeHidden(['solicitacao_exame_id', 'exame_id']);
            });
        });

        return $solicitacoesExames;
    }

    private static function getAtendimentoAtestados($soap)
    {
        $atestados = $soap->atestados()
            ->with([
                'modelo:id,nome',
                'cid:id,codigo,nome',
            ])
            ->get([
                'modelo_id',
                'descricao',
                'nome_acompanhante',
                'documento_tipo_id',
                'cpf',
                'cns',
                'data',
                'horario',
                'dias',
                'cid_id',
            ]);

        $atestados->each(function ($atestado) use ($soap) {

            $atestado->is_atestado_acompanhante = !is_null($atestado->nome_acompanhante);
            $atestado->nome = $atestado->nome_acompanhante ?? $soap->atendimento->paciente->cidadao->nome;

            if (!is_null($atestado->cpf)) {

                $atestado->cpf = MaskUtil::getCpfMasked($atestado->cpf);
            }

            if (!is_null($atestado->cns)) {

                $atestado->cns = MaskUtil::getCnsMasked($atestado->cns);
            }

            $atestado->makeHidden(['nome_acompanhante', 'cid_id', 'modelo_id']);

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

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

        return $atestados;
    }

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

    private static function getAtendimentoCartasMedicas($soap)
    {
        return $soap->cartasMedicas()->get(['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',
                'servicoEspecializadoCiap:id,codigo,descricao',
                'servicoEspecializadoClassificacaoRisco:id,descricao_encaminhamento',
            ])
            ->get([
                'tipo_id',
                'servico_especializado_especialidade_id',
                'servico_especializado_complemento',
                'servico_especializado_cid_id',
                'servico_especializado_ciap_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',
                'tipo_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 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 getPosConsultas($pacienteId)
    {
        return DB::table('ambulatorio_atendimento_pos_consulta')
            ->select([
                'ambulatorio_atendimento_pos_consulta.id',
                'ambulatorio_atendimento_pos_consulta.atendimento_id',
                'ambulatorio_atendimento_pos_consulta.created_at',
                'ocupacao.id AS ocupacao_id',
                'ocupacao.codigo AS ocupacao_codigo',
                'ocupacao.nome AS ocupacao_nome',
                'cadastro_cidadao.nome AS cidadao_nome',
                'cadastro_setor.nome AS setor_nome',
                'cadastro_centro_custo.infraestrutura_id AS centro_custo_infraestrutura_id',
                'cadastro_unidade.nome_fantasia AS unidade_nome_fantasia',
                DB::raw("'Agendada' AS tipo_atendimento"),
            ])
            ->join('ambulatorio_atendimento', 'ambulatorio_atendimento.id', 'ambulatorio_atendimento_pos_consulta.atendimento_id')
            ->join('ambulatorio_agendamento', 'ambulatorio_agendamento.id', 'ambulatorio_atendimento.agendamento_id')
            ->join('cadastro_lotacao', 'cadastro_lotacao.id', 'ambulatorio_atendimento_pos_consulta.created_lotacao_id')
            ->join('cadastro_usuario', 'cadastro_usuario.id', 'cadastro_lotacao.usuario_id')
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->join('sigtap.ocupacao', 'ocupacao.id', 'cadastro_lotacao.ocupacao_id')
            ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'ambulatorio_atendimento_pos_consulta.created_centro_custo_id')
            ->join('cadastro_setor', 'cadastro_setor.id', 'cadastro_centro_custo.setor_id')
            ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'cadastro_centro_custo.infraestrutura_id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'cadastro_infraestrutura.unidade_id')
            ->where('ambulatorio_agendamento.paciente_id', $pacienteId)
            ->unionAll(
                DB::table('ambulatorio_atendimento_pos_consulta')
                    ->select([
                        'ambulatorio_atendimento_pos_consulta.id',
                        'ambulatorio_atendimento_pos_consulta.atendimento_id',
                        'ambulatorio_atendimento_pos_consulta.created_at',
                        'ocupacao.id AS ocupacao_id',
                        'ocupacao.codigo AS ocupacao_codigo',
                        'ocupacao.nome AS ocupacao_nome',
                        'cadastro_cidadao.nome AS cidadao_nome',
                        'cadastro_setor.nome AS setor_nome',
                        'cadastro_centro_custo.infraestrutura_id AS centro_custo_infraestrutura_id',
                        'cadastro_unidade.nome_fantasia AS unidade_nome_fantasia',
                        DB::raw("'Demanda espontânea' AS tipo_atendimento"),
                    ])
                    ->join('ambulatorio_atendimento', 'ambulatorio_atendimento.id', 'ambulatorio_atendimento_pos_consulta.atendimento_id')
                    ->join('ambulatorio_demanda_espontanea', 'ambulatorio_demanda_espontanea.id', 'ambulatorio_atendimento.demanda_espontanea_id')
                    ->join('cadastro_lotacao', 'cadastro_lotacao.id', 'ambulatorio_atendimento_pos_consulta.created_lotacao_id')
                    ->join('cadastro_usuario', 'cadastro_usuario.id', 'cadastro_lotacao.usuario_id')
                    ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
                    ->join('sigtap.ocupacao', 'ocupacao.id', 'cadastro_lotacao.ocupacao_id')
                    ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'ambulatorio_atendimento_pos_consulta.created_centro_custo_id')
                    ->join('cadastro_setor', 'cadastro_setor.id', 'cadastro_centro_custo.setor_id')
                    ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'cadastro_centro_custo.infraestrutura_id')
                    ->join('cadastro_unidade', 'cadastro_unidade.id', 'cadastro_infraestrutura.unidade_id')
                    ->where('ambulatorio_demanda_espontanea.paciente_id', $pacienteId)
            )
            ->get()
            ->map(function ($posConsulta) {
                $posConsulta->created_at = Carbon::create($posConsulta->created_at);

                $posConsulta->createdLotacao = (object) [
                    'ocupacao' => (object) [
                        'id' => $posConsulta->ocupacao_id,
                        'codigo' => $posConsulta->ocupacao_codigo,
                        'nome' => $posConsulta->ocupacao_nome,
                    ],
                    'usuario' => (object) [
                        'cidadao' => (object) [
                            'nome' => $posConsulta->cidadao_nome,
                        ],
                    ],
                ];

                $posConsulta->createdCentroCusto = (object) [
                    'infraestrutura_id' => $posConsulta->centro_custo_infraestrutura_id,
                    'setor' => (object) [
                        'nome' => $posConsulta->setor_nome
                    ],
                    'unidade' => (object) [
                        'nome_fantasia' => $posConsulta->unidade_nome_fantasia
                    ],
                ];

                return (object) array_merge(self::getLogData($posConsulta, 'pos-consulta'), [
                    'id' => $posConsulta->id,
                    'atendimento_id' => $posConsulta->atendimento_id,
                    'is_atendimento_soap_assinado' => false,
                ]);
            });
    }

    public static function getPosConsulta($posConsultaId)
    {
        $posConsulta = AtendimentoPosConsulta::findOrFail($posConsultaId);

        return array_merge(self::getLogData($posConsulta, 'pos-consulta'), [
            'observacoes' => $posConsulta->observacoes,
            'procedimentos' => self::getPosConsultaProcedimentos($posConsulta),
            'desfecho' => self::getPosConsultaDesfecho($posConsulta),
        ]);
    }

    private static function getPosConsultaProcedimentos($posConsulta)
    {
        $procedimentos = $posConsulta->procedimentos()
            ->get([
                'procedimento_id',
                'quantidade',
                'automatico',
                'local_curativo',
                'saida_item_id',
            ]);

        $procedimentos->each(function ($procedimento) {

            $almoxarifadoSaidaItem = $procedimento->almoxarifadoSaidaItem;

            $procedimento->procedimento = self::getProcedimento($procedimento->procedimento_id);

            $procedimento->makeHidden('procedimento_id');

            $procedimento->material_descricao_completa = $almoxarifadoSaidaItem->material->descricaoCompleta ?? null;
            $procedimento->material_quantidade = $almoxarifadoSaidaItem->quantidade ?? null;
        });

        return $procedimentos;
    }

    private static function getPosConsultaDesfecho($posConsulta)
    {
        return $posConsulta->paciente_liberado
            ? Desfecho::PACIENTE_LIBERADO
            : Desfecho::MANTER_NA_FILA;
    }

    private static function getLogData($model, $tipo)
    {
        return [
            'tipo' => $tipo,
            'data_hora' => $model->created_at,
            'lotacao' => [
                'ocupacao' => [
                    'id' => $model->createdLotacao->ocupacao->id,
                    'codigo' => $model->createdLotacao->ocupacao->codigo,
                    'nome' => $model->createdLotacao->ocupacao->nome,
                ],
                'profissional' => [
                    'nome' => $model->createdLotacao->usuario->cidadao->nome ?? null,
                ],
            ],
            'centro_custo' => [
                'infraestrutura' => [
                    'id' => $model->createdCentroCusto->infraestrutura_id,
                ],
                'setor' => [
                    'nome' => $model->createdCentroCusto->setor->nome,
                ],
                'unidade' => [
                    'nome_fantasia' => $model->createdCentroCusto->unidade->nome_fantasia ?? null,
                ],
            ],
            'tipo_atendimento' => $model->tipo_atendimento ?? null,
        ];
    }

    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 getExame($exameId)
    {
        return DB::table('parametrizacao_exame')
            ->where('id', $exameId)
            ->select(
                'codigo',
                'nome'
            )
            ->first();
    }

    private static function getAtendimentoPuericulturaQuestionarioMChatR($soap)
    {
        $score = PuericulturaQuestionarioMChatR::orderBy('id')
            ->get()
            ->reduce(function ($total, $query) use ($soap) {
                $questionario = $soap->puericulturaQuestionarioMChatR()
                    ->where('questionario_m_chat_r_id', $query->id)
                    ->first();

                $valor = optional($questionario)->resposta
                    ? $query->valor_resposta_sim
                    : $query->valor_resposta_nao;

                return $total + $valor;
            }, 0);

        $classificacao = null;

        if ($score <= 2) {
            $classificacao = 'Baixo risco';
        } elseif ($score >= 3 && $score <= 7) {
            $classificacao = 'Risco moderado';
        } elseif ($score >= 8) {
            $classificacao = 'Alto risco';
        }

        return [[
            'atendimento_id' => $soap->atendimento_id,
            'soap_id' => $soap->id,
            'data_hora_atendimento' => $soap->created_at->format('d/m/Y \à\s H:i'),
            'usuario_nome' => $soap->createdLotacao->usuario->cidadao->nome ?? null,
            'score' => $score,
            'classificacao' => $classificacao,
        ]];
    }
}