<?php

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

use App\Models\Ambulatorio\GlicemiaCapilarMomentoColeta;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\LocalAtendimento;
use App\Models\AtencaoBasica\Procedimento\PequenaCirurgia;
use App\Models\AtencaoBasica\Procedimento\TesteRapido;
use App\Models\AtencaoBasica\Procedimento\ViaAdministracao;
use App\Models\Geral\Turno;
use App\Models\Sigtap\Ocupacao;
use App\Models\Sigtap\Procedimento;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;
use stdClass;

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

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

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

        $this->setProfissional($path);
        $this->setAtendimentos($path);
        $this->setProcedimentosConsolidados($path);

        return $this->ficha;
    }

    private function setProfissional($fichaProcedimentoMasterTransportPath)
    {
        $headerTransportPath = "{$fichaProcedimentoMasterTransportPath}/headerTransport";

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

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

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

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

    private function setAtendimentos($fichaProcedimentoMasterTransportPath)
    {
        $path = "{$fichaProcedimentoMasterTransportPath}/atendProcedimentos";

        $atendimentos = [];

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

            $posicao = $i + 1;

            $atendimentoModel = $this->inconsistenciaModel->procedimentoAtendimentos()
                ->wherePivot('posicao', $posicao)
                ->first();

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

            $atendimento = new stdClass;

            $this->setAtendimento($atendimento, $context, $atendimentoModel, $inconsistencias);
            $this->setInformacoesGerais($atendimento, $context, $inconsistencias);
            $this->setProcedimentos($atendimento, $context, $inconsistencias);

            $atendimentos[] = $atendimento;
        }

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

    private function setAtendimento($atendimento, $atendimentoContext, $atendimentoModel, $inconsistencias)
    {
        $campos = (object) [
            'numProntuario' => $this->getFirstNodeValue('numProntuario', $atendimentoContext),
            'nomeCidadao' => $atendimentoModel->paciente->cidadao->nome,
            'cnsCidadao' => MaskUtil::getCnsMasked($this->getFirstNodeValue('cnsCidadao', $atendimentoContext)),
            'cpfCidadao' => MaskUtil::getCpfMasked($this->getFirstNodeValue('cpfCidadao', $atendimentoContext)),
            'dtNascimento' => $this->getDateString($this->getFirstNodeValue('dtNascimento', $atendimentoContext)),
            'sexo' => $this->getSexo($this->getFirstNodeValue('sexo', $atendimentoContext)),
            'localAtendimento' => $this->getFirstNodeValue('localAtendimento', $atendimentoContext)
                ? LocalAtendimento::find($this->getFirstNodeValue('localAtendimento', $atendimentoContext))->descricao
                : null,
            'turno' => $this->getFirstNodeValue('turno', $atendimentoContext)
                ? Turno::find($this->getFirstNodeValue('turno', $atendimentoContext))->nome
                : null,
            'statusEscutaInicialOrientacao' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue('statusEscutaInicialOrientacao', $atendimentoContext))),
            'dataHoraInicialAtendimento' => $this->getDateTimeString(
                $this->getFirstNodeValue('dataHoraInicialAtendimento', $atendimentoContext)),
            'dataHoraFinalAtendimento' => $this->getDateTimeString(
                $this->getFirstNodeValue('dataHoraFinalAtendimento', $atendimentoContext)),
        ];

        $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],
            ['Local de atendimento', fn () => $inconsistencias->localAtendimento],
            ['Turno', fn () => $inconsistencias->turno],
            ['Escuta Inicial/Orientação', fn () => $inconsistencias->statusEscutaInicialOrientacao],
            ['Data/hora inicial do atendimento', fn () => $inconsistencias->dataHoraInicialAtendimento],
            ['Data/hora final do atendimento', fn () => $inconsistencias->dataHoraFinalAtendimento],
        ]);

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

    private function setInformacoesGerais($atendimento, $atendimentoContext, $inconsistencias)
    {
        $medicoes = $this->domx->query('medicoes', $atendimentoContext);
        $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->informacoes_gerais = (object) compact('campos', 'inconsistencias');
    }

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

        foreach ($this->domx->query('procedimentos', $atendimentoContext) as $context) {

            $codigo = $context->nodeValue;

            if ($pequenaCirurgia = PequenaCirurgia::where('codigo_esus', $codigo)->first()) {

                $procedimentos[] = "Pequena cirurgia: {$pequenaCirurgia->descricao}";
            }
            else if ($testeRapido = TesteRapido::where('codigo_esus', $codigo)->first()) {

                $procedimentos[] = "Teste rápido: {$testeRapido->descricao}";
            }
            else if ($viaAdmnistracao = ViaAdministracao::where('codigo_esus', $codigo)->first()) {

                $procedimentos[] = "Administração de medicamento: {$viaAdmnistracao->descricao}";
            }
            else {

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

                $procedimentos[] = MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}";
            }
        }

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

    private function setProcedimentosConsolidados($fichaProcedimentoMasterTransportPath)
    {
        $path = $fichaProcedimentoMasterTransportPath;

        $campos = (object) [
            'numTotalAfericaoPa' => $this->getFirstNodeValue("{$path}/numTotalAfericaoPa"),
            'numTotalAfericaoTemperatura' => $this->getFirstNodeValue("{$path}/numTotalAfericaoTemperatura"),
            'numTotalCurativoSimples' => $this->getFirstNodeValue("{$path}/numTotalCurativoSimples"),
            'numTotalColetaMaterialParaExameLaboratorial' => $this->getFirstNodeValue("{$path}/numTotalColetaMaterialParaExameLaboratorial"),
            'numTotalGlicemiaCapilar' => $this->getFirstNodeValue("{$path}/numTotalGlicemiaCapilar"),
            'numTotalMedicaoAltura' => $this->getFirstNodeValue("{$path}/numTotalMedicaoAltura"),
            'numTotalMedicaoPeso' => $this->getFirstNodeValue("{$path}/numTotalMedicaoPeso"),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Aferição de PA', fn () => $this->inconsistencias->numTotalAfericaoPa],
            ['Temperatura', fn () => $this->inconsistencias->numTotalAfericaoTemperatura],
            ['Curativo', fn () => $this->inconsistencias->numTotalCurativoSimples],
            ['Coleta de material para Exame Laboratorial', fn () => $this->inconsistencias->numTotalColetaMaterialParaExameLaboratorial],
            ['Glicemia Capilar', fn () => $this->inconsistencias->numTotalGlicemiaCapilar],
            ['Altura', fn () => $this->inconsistencias->numTotalMedicaoAltura],
            ['Peso', fn () => $this->inconsistencias->numTotalMedicaoPeso],
        ]);

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