<?php

namespace App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha;

use App\Enums\AtencaoBasica\AtendimentoOdontologico\CondutaEncaminhamento;
use App\Enums\AtencaoBasica\AtendimentoOdontologico\Fornecimento;
use App\Enums\AtencaoBasica\AtendimentoOdontologico\VigilanciaBucal;
use App\Enums\Cadastro\SujeitoAtencao\Sexo;
use App\Enums\Integracao\Esus\Procedimentos as ProcedimentoEsus;
use App\Models\Ambulatorio\GlicemiaCapilarMomentoColeta;
use App\Models\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
use App\Models\AtencaoBasica\AtendimentoOdontologico\TipoConsulta;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\LocalAtendimento;
use App\Models\Geral\Ciap;
use App\Models\Geral\Turno;
use App\Models\Sigtap\Cid;
use App\Models\Sigtap\Ocupacao;
use App\Models\Sigtap\Procedimento;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;
use stdClass;

class FichaAtendimentoOdontologico extends Ficha
{
    public function __construct($xmlEnvio, $inconsistenciaModel)
    {
        parent::__construct($xmlEnvio, $inconsistenciaModel);

        $this->domx->registerNamespace('ns4', 'http://esus.ufsc.br/fichaatendimentoodontologicomaster');
    }

    public function __invoke()
    {
        $path = '//ns4:fichaAtendimentoOdontologicoMasterTransport';

        $this->setProfissionalResponsavel($path);
        $this->setProfissionalAuxiliar($path);
        $this->setAtendimentos($path);

        return $this->ficha;
    }

    private function setProfissionalResponsavel($fichaAtendimentoOdontologicoMasterTransportPath)
    {
        $headerTransportPath = "{$fichaAtendimentoOdontologicoMasterTransportPath}/headerTransport";
        $lotacaoFormPrincipalPath = "{$headerTransportPath}/lotacaoFormPrincipal";

        $ocupacao = $this->getFirstNodeValue("{$lotacaoFormPrincipalPath}/cboCodigo_2002")
            ? Ocupacao::where('codigo', $this->getFirstNodeValue("{$lotacaoFormPrincipalPath}/cboCodigo_2002"))->first()
            : null;

        $campos = (object) [
            'dataAtendimento' => $this->getDateString($this->getFirstNodeValue("{$headerTransportPath}/dataAtendimento")),
            'codigoIbgeMunicipio' => $this->getFirstNodeValue("{$headerTransportPath}/codigoIbgeMunicipio"),
            'profissionalNome' => $this->inconsistenciaModel->usuario->cidadao->nome,
            'profissionalCNS' => MaskUtil::getCnsMasked($this->getFirstNodeValue("{$lotacaoFormPrincipalPath}/profissionalCNS")),
            'cboCodigo_2002' => $ocupacao ? "{$ocupacao->codigo} - {$ocupacao->nome}" : null,
            'cnes' => $this->getFirstNodeValue("{$lotacaoFormPrincipalPath}/cnes"),
            'ine' => $this->getFirstNodeValue("{$lotacaoFormPrincipalPath}/ine"),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Data', fn () => $this->inconsistencias->headerTransport->dataAtendimento],
            ['IBGE', fn () => $this->inconsistencias->headerTransport->codigoIbgeMunicipio],
            ['CNS', fn () => $this->inconsistencias->headerTransport->lotacaoFormPrincipal->profissionalCNS],
            ['CBO', fn () => $this->inconsistencias->headerTransport->lotacaoFormPrincipal->cboCodigo_2002],
            ['CNES', fn () => $this->inconsistencias->headerTransport->lotacaoFormPrincipal->cnes],
            ['INE', fn () => $this->inconsistencias->headerTransport->lotacaoFormPrincipal->ine],
        ]);

        $this->ficha->profissional_responsavel = (object) compact('campos', 'inconsistencias');
    }

    private function setProfissionalAuxiliar($fichaAtendimentoOdontologicoMasterTransportPath)
    {
        $headerTransportPath = "{$fichaAtendimentoOdontologicoMasterTransportPath}/headerTransport";
        $lotacaoFormAtendimentoCompartilhadoPath = "{$headerTransportPath}/lotacaoFormAtendimentoCompartilhado";

        $ocupacao = $this->getFirstNodeValue("{$lotacaoFormAtendimentoCompartilhadoPath}/cboCodigo_2002")
            ? Ocupacao::where('codigo', $this->getFirstNodeValue("{$lotacaoFormAtendimentoCompartilhadoPath}/cboCodigo_2002"))->first()
            : null;

        $cns = $this->getFirstNodeValue("{$lotacaoFormAtendimentoCompartilhadoPath}/profissionalCNS");

        $campos = (object) [
            'profissionalNome' => $this->inconsistenciaModel->atendimentosOdontologicos()
                ->whereHas('usuarioAuxiliar', fn ($q) => $q
                    ->whereHas('cidadao', fn ($q) => $q->where('cns', $cns))
                )
                ->first()->usuarioAuxiliar->cidadao->nome ?? null,
            'profissionalCNS' => MaskUtil::getCnsMasked($cns),
            'cboCodigo_2002' => $ocupacao ? "{$ocupacao->codigo} - {$ocupacao->nome}" : null,
            'cnes' => $this->getFirstNodeValue("{$lotacaoFormAtendimentoCompartilhadoPath}/cnes"),
            'ine' => $this->getFirstNodeValue("{$lotacaoFormAtendimentoCompartilhadoPath}/ine"),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['CNS', fn () => $this->inconsistencias->headerTransport->lotacaoFormAtendimentoCompartilhado->profissionalCNS],
            ['CBO', fn () => $this->inconsistencias->headerTransport->lotacaoFormAtendimentoCompartilhado->cboCodigo_2002],
            ['CNES', fn () => $this->inconsistencias->headerTransport->lotacaoFormAtendimentoCompartilhado->cnes],
            ['INE', fn () => $this->inconsistencias->headerTransport->lotacaoFormAtendimentoCompartilhado->ine],
        ]);

        $this->ficha->profissional_auxiliar = (object) compact('campos', 'inconsistencias');
    }

    private function setAtendimentos($fichaAtendimentoOdontologicoMasterTransportPath)
    {
        $path = "{$fichaAtendimentoOdontologicoMasterTransportPath}/atendimentosOdontologicos";

        $atendimentos = [];

        foreach ($this->domx->query($path) as $i => $context) {

            $posicao = $i + 1;

            $atendimentoOdontologicoModel = $this->inconsistenciaModel->atendimentosOdontologicos()
                ->wherePivot('posicao', $posicao)
                ->first();

            $inconsistencias = $this->inconsistencias->atendimentosOdontologicos->{$posicao} ?? [];

            $atendimento = new stdClass;

            $this->setPaciente($atendimento, $context, $atendimentoOdontologicoModel, $inconsistencias);
            $this->setAtendimento($atendimento, $context, $inconsistencias);
            $this->setVigilancia($atendimento, $context, $inconsistencias);
            $this->setProblemasCondicoes($atendimento, $context, $inconsistencias);
            $this->setMedicoes($atendimento, $context, $inconsistencias);
            $this->setProcedimentos($atendimento, $context, $inconsistencias);
            $this->setFornecimento($atendimento, $context, $inconsistencias);
            $this->setConduta($atendimento, $context, $inconsistencias);
            $this->setSolicitacoesOci($atendimento, $context, $inconsistencias);
            $this->setExames($atendimento, $context, $inconsistencias);
            $this->setIvcf($atendimento, $context, $inconsistencias);

            $atendimentos[] = $atendimento;
        }

        $this->ficha->atendimentos = (object) [
            'lista' => $atendimentos,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $this->inconsistencias->atendimentosOdontologicos,
            ]),
        ];
    }

    private function setPaciente($atendimento, $atendimentoOdontologicoContext, $atendimentoOdontologicoModel, $inconsistencias)
    {
        $campos = (object) [
            'is_sexo_feminino' => $atendimentoOdontologicoModel->paciente->cidadao->sexo_id === Sexo::FEMININO,
            'nomeCidadao' => $atendimentoOdontologicoModel->paciente->cidadao->nome,
            'numProntuario' => $this->getFirstNodeValue('numProntuario', $atendimentoOdontologicoContext),
            'cnsCidadao' => MaskUtil::getCnsMasked($this->getFirstNodeValue('cnsCidadao', $atendimentoOdontologicoContext)),
            'cpfCidadao' => MaskUtil::getCpfMasked($this->getFirstNodeValue('cpfCidadao', $atendimentoOdontologicoContext)),
            'dtNascimento' => $this->getDateString($this->getFirstNodeValue('dtNascimento', $atendimentoOdontologicoContext)),
            'sexo' => $this->getSexo($this->getFirstNodeValue('sexo', $atendimentoOdontologicoContext)),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Prontuário', fn () => $inconsistencias->numProntuario],
            ['CNS', fn () => $inconsistencias->cnsCidadao],
            ['CPF', fn () => $inconsistencias->cpfCidadao],
            ['Data de nascimento', fn () => $inconsistencias->dtNascimento],
            ['Sexo', fn () => $inconsistencias->sexo],
        ]);

        $atendimento->paciente = (object) compact('campos', 'inconsistencias');
    }

    private function setAtendimento($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $campos = (object) [
            'turno' => $this->getFirstNodeValue('turno', $atendimentoOdontologicoContext)
                ? Turno::find($this->getFirstNodeValue('turno', $atendimentoOdontologicoContext))->nome
                : null,
            'localAtendimento' => $this->getFirstNodeValue('localAtendimento', $atendimentoOdontologicoContext)
                ? LocalAtendimento::find($this->getFirstNodeValue('localAtendimento', $atendimentoOdontologicoContext))->descricao
                : null,
            'tipoAtendimento' => $this->getFirstNodeValue('tipoAtendimento', $atendimentoOdontologicoContext)
                ? TipoAtendimento::where(
                    'codigo_esus',
                    $this->getFirstNodeValue('tipoAtendimento', $atendimentoOdontologicoContext)
                )->first()->descricao
                : null,
            'tiposConsultaOdonto' => $this->getFirstNodeValue('tiposConsultaOdonto', $atendimentoOdontologicoContext)
                ? TipoConsulta::where(
                    'codigo_esus',
                    $this->getFirstNodeValue('tiposConsultaOdonto', $atendimentoOdontologicoContext)
                )->first()->descricao
                : null,
            'gestante' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue('gestante', $atendimentoOdontologicoContext))),
            'necessidadesEspeciais' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue('necessidadesEspeciais', $atendimentoOdontologicoContext))),
            'dataHoraInicialAtendimento' => $this->getDateTimeString(
                $this->getFirstNodeValue('dataHoraInicialAtendimento', $atendimentoOdontologicoContext)),
            'dataHoraFinalAtendimento' => $this->getDateTimeString(
                $this->getFirstNodeValue('dataHoraFinalAtendimento', $atendimentoOdontologicoContext)),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Turno', fn () => $inconsistencias->turno],
            ['Local de atendimento', fn () => $inconsistencias->localAtendimento],
            ['Tipo de atendimento', fn () => $inconsistencias->tipoAtendimento],
            ['Tipo de consulta', fn () => $inconsistencias->tiposConsultaOdonto],
            ['Gestante', fn () => $inconsistencias->gestante],
            ['Necessidades especiais', fn () => $inconsistencias->necessidadesEspeciais],
            ['Data/hora inicial do atendimento', fn () => $inconsistencias->dataHoraInicialAtendimento],
            ['Data/hora final do atendimento', fn () => $inconsistencias->dataHoraFinalAtendimento],
        ]);

        $atendimento->atendimento = (object) compact('campos', 'inconsistencias');
    }

    private function setVigilancia($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $vigilancias = [];

        $getNome = function ($id) {
            switch ($id) {
                case VigilanciaBucal::ABSCESSO_DENTO_ALVEOLAR: {
                    return 'Abscesso Dento Alveolar';
                }
                case VigilanciaBucal::ALTERACAO_EM_TECIDOS_MOLES: {
                    return 'Alteração em Tecidos Moles';
                }
                case VigilanciaBucal::DOR_DE_DENTE: {
                    return 'Dor De Dente';
                }
                case VigilanciaBucal::FENDAS_FISSURAS_LABIO_PALATAIS: {
                    return 'Fendas ou Fissuras Lábio Palatais';
                }
                case VigilanciaBucal::FLUOROSE_DENTARIA_MODERADA_SEVERA: {
                    return 'Fluorose Dentária Moderada ou Sevéra';
                }
                case VigilanciaBucal::TRAUMATISMO_DENTO_ALVEOLAR: {
                    return 'Traumatismo Dento Alveolar';
                }
                case VigilanciaBucal::NAO_IDENTIFICADO: {
                    return 'Não Identificado';
                }
            }
        };

        foreach ($this->domx->query('tiposVigilanciaSaudeBucal', $atendimentoOdontologicoContext) as $context) {

            $vigilancias[] = $getNome($context->nodeValue);
        }

        $atendimento->vigilancias = (object) [
            'lista' => $vigilancias,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $inconsistencias->tiposVigilanciaSaudeBucal,
            ]),
        ];
    }

    private function setProblemasCondicoes($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $problemasCondicoes = [];

        foreach ($this->domx->query('problemasCondicoes', $atendimentoOdontologicoContext) as $context) {

            $ciap = $this->getFirstNodeValue('ciap', $context)
                ? Ciap::where('codigo', $this->getFirstNodeValue('ciap', $context))->first()
                : null;

            $cid = $this->getFirstNodeValue('cid10', $context)
                ? Cid::where('codigo', $this->getFirstNodeValue('cid10', $context))->first()
                : null;

            $problemasCondicoes[] = (object) [
                'ciap' => $ciap ? "{$ciap->codigo} - {$ciap->descricao}" : null,
                'cid10' => $cid ? MaskUtil::getCidMasked($cid->codigo) . " - {$cid->nome}" : null,
                'isAvaliado' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                    $this->getFirstNodeValue('isAvaliado', $context))),
            ];
        }

        $atendimento->problemas_condicoes = (object) [
            'lista' => $problemasCondicoes,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $inconsistencias->problemasCondicoes,
            ]),
        ];
    }

    private function setMedicoes($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $medicoes = $this->domx->query('medicoes', $atendimentoOdontologicoContext);
        $medicoesContext = $medicoes->length > 0 ? $medicoes[0] : null;

        $campos = (object) [
            'circunferenciaAbdominal' => $this->getFirstNodeValue('circunferenciaAbdominal', $medicoesContext),
            'perimetroPanturrilha' => $this->getFirstNodeValue('perimetroPanturrilha', $medicoesContext),
            'pressaoArterial' => trim($this->getFirstNodeValue('pressaoArterialSistolica', $medicoesContext)
                . '/' . $this->getFirstNodeValue('pressaoArterialDiastolica', $medicoesContext), '/'),
            'frequenciaRespiratoria' => $this->getFirstNodeValue('frequenciaRespiratoria', $medicoesContext),
            'frequenciaCardiaca' => $this->getFirstNodeValue('frequenciaCardiaca', $medicoesContext),
            'temperatura' => $this->getFirstNodeValue('temperatura', $medicoesContext),
            'saturacaoO2' => $this->getFirstNodeValue('saturacaoO2', $medicoesContext),
            'glicemiaCapilar' => $this->getFirstNodeValue('glicemiaCapilar', $medicoesContext),
            'tipoGlicemiaCapilar' => !is_null($this->getFirstNodeValue('tipoGlicemiaCapilar', $medicoesContext))
                ? GlicemiaCapilarMomentoColeta::where(
                    'codigo_esus',
                    $this->getFirstNodeValue('tipoGlicemiaCapilar', $medicoesContext)
                )->first()->nome
                : null,
            'peso' => $this->getFirstNodeValue('peso', $medicoesContext),
            'altura' => $this->getFirstNodeValue('altura', $medicoesContext),
            'perimetroCefalico' => $this->getFirstNodeValue('perimetroCefalico', $medicoesContext),
        ];

        $inconsistencias = $this->getInconsistencias([
            fn () => $inconsistencias->medicoes,
            ['Circunferência abdominal', fn () => $inconsistencias->medicoes->circunferenciaAbdominal],
            ['Perímetro da panturrilha', fn () => $inconsistencias->medicoes->perimetroPanturrilha],
            ['Pressão arterial sistólica', fn () => $inconsistencias->medicoes->pressaoArterialSistolica],
            ['Pressão arterial diastólica', fn () => $inconsistencias->medicoes->pressaoArterialDiastolica],
            ['Frequência respiratória', fn () => $inconsistencias->medicoes->frequenciaRespiratoria],
            ['Frequência cardíaca', fn () => $inconsistencias->medicoes->frequenciaCardiaca],
            ['Temperatura', fn () => $inconsistencias->medicoes->temperatura],
            ['Saturação de O2', fn () => $inconsistencias->medicoes->saturacaoO2],
            ['Glicemia capilar', fn () => $inconsistencias->medicoes->glicemiaCapilar],
            ['Momento da coleta', fn () => $inconsistencias->medicoes->tipoGlicemiaCapilar],
            ['Peso', fn () => $inconsistencias->medicoes->peso],
            ['Altura', fn () => $inconsistencias->medicoes->altura],
            ['Perímetro cefálico', fn () => $inconsistencias->medicoes->perimetroCefalico],
        ]);

        $atendimento->medicoes = (object) compact('campos', 'inconsistencias');
    }

private function setProcedimentos($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
{
    $procedimentos = [];

    foreach ($this->domx->query('procedimentosRealizados', $atendimentoOdontologicoContext) as $context) {
        $codigo = $this->getFirstNodeValue('coMsProcedimento', $context);

        if ($codigo === ProcedimentoEsus::ORIENTACAO_EM_SAUDE) {

            $descricao = $codigo . " - Orientação Individual em Saúde";

        } else {
            $procedimento = Procedimento::where('codigo', $codigo)
                ->orderByDesc('competencia_id')
                ->first();

            $descricao = $procedimento->codigo . " - {$procedimento->nome}";
        }

        $procedimentos[] = (object) [
            'descricao' => $descricao,
            'quantidade' => $this->getFirstNodeValue('quantidade', $context),
        ];
    }

        $procedimentosCallbacks = [];

        $procedimentosRealizados = is_object($inconsistencias) ? ($inconsistencias->procedimentosRealizados ?? null) : null;

        if (!empty($procedimentosRealizados)) {
            foreach ($procedimentosRealizados as $item) {
                foreach ((array) $item as $msg) {
                    $mensagem = $msg;
                    $procedimentosCallbacks[] = function () use ($mensagem) {
                        return $mensagem;
                    };
                }
            }
        }

    $atendimento->procedimentos = (object) [
        'lista' => $procedimentos,
        'inconsistencias' => $this->getInconsistencias($procedimentosCallbacks),
    ];
}

    private function setFornecimento($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $fornecimentos = [];

        $getNome = function ($id) {
            switch ($id) {
                case Fornecimento::ESCOVA_DENTAL: {
                    return 'Escova Dental';
                }
                case Fornecimento::CREME_DENTAL: {
                    return 'Creme Dental';
                }
                case Fornecimento::FIO_DENTAL: {
                    return 'Fio Dental';
                }
            }
        };

        foreach ($this->domx->query('tiposFornecimOdonto', $atendimentoOdontologicoContext) as $context) {

            $fornecimentos[] = $getNome($context->nodeValue);
        }

        $atendimento->fornecimentos = (object) [
            'lista' => $fornecimentos,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $inconsistencias->tiposFornecimOdonto,
            ]),
        ];
    }

    private function setConduta($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $condutas = [];

        $getNome = function ($id) {
            switch ($id) {
                case CondutaEncaminhamento::ALTA_EPISODIO: {
                    return 'Alta do episódio';
                }
                case CondutaEncaminhamento::RETORNO_CONSULTA_AGENDADA: {
                    return 'Retorno para Consulta Agendada';
                }
                case CondutaEncaminhamento::AGENDAMENTO_OUTROS_PROFISSIONAIS: {
                    return 'Agendamento para Outros Profissionais AB';
                }
                case CondutaEncaminhamento::AGENDAMENTO_PARA_E_MULTI: {
                    return 'Agendamento para eMulti';
                }
                case CondutaEncaminhamento::AGENDAMENTO_GRUPOS: {
                    return 'Agendamento para Grupos';
                }
                case CondutaEncaminhamento::TRATAMENTO_CONCLUIDO: {
                    return 'Tratamento Concluído';
                }
                case CondutaEncaminhamento::ATENDIMENTO_PACIENTES_NECESSIDADES_ESPECIAIS: {
                    return 'Encaminhamento: Atendimento à Pacientes com Necessidades Especiais';
                }
                case CondutaEncaminhamento::CIRURGIA_BMF: {
                    return 'Encaminhamento: Cirurgia BMF';
                }
                case CondutaEncaminhamento::ENDODONTIA: {
                    return 'Encaminhamento: Endodontia';
                }
                case CondutaEncaminhamento::ESTOMATOLOGIA: {
                    return 'Encaminhamento: Estomatologia';
                }
                case CondutaEncaminhamento::IMPLANTODONTIA: {
                    return 'Encaminhamento: Implantodontia';
                }
                case CondutaEncaminhamento::ODONTOPEDIATRIA: {
                    return 'Encaminhamento: Odontopediatria';
                }
                case CondutaEncaminhamento::ORTODONTIA_ORTOPEDIA: {
                    return 'Encaminhamento: Ortodontia/Ortopedia';
                }
                case CondutaEncaminhamento::PERIDONTIA: {
                    return 'Encaminhamento: Peridontia';
                }
                case CondutaEncaminhamento::PROTESE_DENTARIA: {
                    return 'Encaminhamento: Prótese Dentária';
                }
                case CondutaEncaminhamento::RADIOLOGIA: {
                    return 'Encaminhamento: Radiologia';
                }
                case CondutaEncaminhamento::OUTROS: {
                    return 'Encaminhamento: Outros';
                }
            }
        };

        foreach ($this->domx->query('tiposEncamOdonto', $atendimentoOdontologicoContext) as $context) {

            $condutas[] = $getNome($context->nodeValue);
        }

        $atendimento->condutas = (object) [
            'lista' => $condutas,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $inconsistencias->tiposEncamOdonto,
            ]),
        ];
    }

    private function setSolicitacoesOci($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $solicitacoesOci = [];

        foreach ($this->domx->query('solicitacoesOci', $atendimentoOdontologicoContext) as $context) {

            $solicitacoesOci[] = (object) [
                'codigoSigtap' => MaskUtil::getProcedimentoMasked($this->getFirstNodeValue('codigoSigtap', $context)),
            ];
        }

        $atendimento->solicitacoes_oci = (object) [
            'lista' => $solicitacoesOci,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $inconsistencias->solicitacoesOci,
            ]),
        ];
    }

    private function setExames($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $exames = [];

        foreach ($this->domx->query('exame', $atendimentoOdontologicoContext) as $context) {

            $exames[] = (object) [
                'codigoExame' => $this->getFirstNodeValue('codigoExame', $context),
                'solicitadoAvaliado' => $this->getFirstNodeValue('solicitadoAvaliado', $context) === 'S' ? 'Solicitado' : 'Avaliado',
            ];
        }

        $atendimento->exames = (object) [
            'lista' => $exames,
            'inconsistencias' => $this->getInconsistencias([
                fn () => $inconsistencias->exame,
            ]),
        ];
    }

    private function setIvcf($atendimento, $atendimentoOdontologicoContext, $inconsistencias)
    {
        $campos = (object) [
            'resultado' => $this->getFirstNodeValue('ivcf/resultado', $atendimentoOdontologicoContext),
            'hasSgIdade' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgIdade', $atendimentoOdontologicoContext))),
            'hasSgPercepcaoSaude' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgPercepcaoSaude', $atendimentoOdontologicoContext))),
            'hasSgAvdInstrumental' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgAvdInstrumental', $atendimentoOdontologicoContext))),
            'hasSgAvdBasica' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgAvdBasica', $atendimentoOdontologicoContext))),
            'hasSgCognicao' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgCognicao', $atendimentoOdontologicoContext))),
            'hasSgHumor' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgHumor', $atendimentoOdontologicoContext))),
            'hasSgAlcancePreensaoPinca' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgAlcancePreensaoPinca', $atendimentoOdontologicoContext))),
            'hasSgCapAerobicaMuscular' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgCapAerobicaMuscular', $atendimentoOdontologicoContext))),
            'hasSgMarcha' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgMarcha', $atendimentoOdontologicoContext))),
            'hasSgContinencia' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgContinencia', $atendimentoOdontologicoContext))),
            'hasSgVisao' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgVisao', $atendimentoOdontologicoContext))),
            'hasSgAudicao' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgAudicao', $atendimentoOdontologicoContext))),
            'hasSgComorbidade' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue('ivcf/hasSgComorbidade', $atendimentoOdontologicoContext))),
            'dataResultado' => $this->getFirstNodeValue('ivcf/dataResultado', $atendimentoOdontologicoContext),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Resultado', fn () => $inconsistencias->ivcf->resultado],
            ['Idade', fn () => $inconsistencias->ivcf->hasSgIdade],
            ['Percepção de saúde', fn () => $inconsistencias->ivcf->hasSgPercepcaoSaude],
            ['Atividades instrumentais da vida diária', fn () => $inconsistencias->ivcf->hasSgAvdInstrumental],
            ['Atividades básicas da vida diária', fn () => $inconsistencias->ivcf->hasSgAvdBasica],
            ['Cognição', fn () => $inconsistencias->ivcf->hasSgCognicao],
            ['Humor', fn () => $inconsistencias->ivcf->hasSgHumor],
            ['Alcance preensão pinça', fn () => $inconsistencias->ivcf->hasSgAlcancePreensaoPinca],
            ['Capacidade aeróbica muscular', fn () => $inconsistencias->ivcf->hasSgCapAerobicaMuscular],
            ['Marcha', fn () => $inconsistencias->ivcf->hasSgMarcha],
            ['Continência', fn () => $inconsistencias->ivcf->hasSgContinencia],
            ['Visão', fn () => $inconsistencias->ivcf->hasSgVisao],
            ['Audição', fn () => $inconsistencias->ivcf->hasSgAudicao],
            ['Comorbidade', fn () => $inconsistencias->ivcf->hasSgComorbidade],
            ['Data do resultado', fn () => $this->getDateString($inconsistencias->ivcf->dataResultado)],
        ]);

        $atendimento->ivcf = (object) compact('campos', 'inconsistencias');
    }
}