<?php

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

use App\Enums\AtencaoBasica\VisitaDomiciliar\MotivoVisita as MotivoVisitaEnum;
use App\Models\AtencaoBasica\CadastroDomiciliar\ImovelTipo;
use App\Models\AtencaoBasica\VisitaDomiciliar\Desfecho;
use App\Models\AtencaoBasica\VisitaDomiciliar\MomentoColeta;
use App\Models\AtencaoBasica\VisitaDomiciliar\MotivoVisita;
use App\Models\Geral\Turno;
use App\Models\Sigtap\Ocupacao;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;
use stdClass;

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

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

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

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

        return $this->ficha;
    }

    private function setProfissional($fichaVisitaDomiciliarMasterTransportPath)
    {
        $headerTransportPath = "{$fichaVisitaDomiciliarMasterTransportPath}/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->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($fichaVisitaDomiciliarMasterTransportPath)
    {
        $path = "{$fichaVisitaDomiciliarMasterTransportPath}/visitasDomiciliares";

        $atendimentos = [];

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

            $posicao = $i + 1;

            $visitaDomiciliarModel = $this->inconsistenciaModel->visitasDomiciliares()
                ->wherePivot('posicao', $posicao)
                ->first();

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

            $atendimento = new stdClass;

            $this->setPaciente($atendimento, $context, $visitaDomiciliarModel, $inconsistencias, $posicao);
            $this->setAtendimento($atendimento, $context, $inconsistencias);
            $this->setAvaliacaoAntropometriza($atendimento, $context, $inconsistencias);
            $this->setMotivosVisita($atendimento, $context, $inconsistencias);
            $this->setSinaisVitais($atendimento, $context, $inconsistencias);
            $this->setGlicemia($atendimento, $context, $inconsistencias);
            $this->setDesfecho($atendimento, $context, $inconsistencias);

            $atendimentos[] = $atendimento;
        }

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

    private function setPaciente($atendimento, $atendimentoContext, $visitaDomiciliarModel, $inconsistencias, $posicao)
    {
        $campos = (object) [
            'numProntuario' => $this->getFirstNodeValue('numProntuario', $atendimentoContext),
            'nomeCidadao' => $visitaDomiciliarModel->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)),
            'microArea' => $this->getFirstNodeValue('microArea', $atendimentoContext),
            'stForaArea' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue('stForaArea', $atendimentoContext))),
            'posicao' =>  $posicao
        ];

        $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],
            ['Microárea', fn () => $inconsistencias->microArea],
            ['Fora de área', fn () => $inconsistencias->stForaArea],
        ]);

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

    private function setAtendimento($atendimento, $atendimentoContext, $inconsistencias)
    {
        $campos = (object) [
            'turno' => $this->getFirstNodeValue('turno', $atendimentoContext)
                ? Turno::find($this->getFirstNodeValue('turno', $atendimentoContext))->nome
                : null,
            'tipoDeImovel' => $this->getFirstNodeValue('tipoDeImovel', $atendimentoContext)
                ? ImovelTipo::where(
                    'codigo_esus',
                    $this->getFirstNodeValue('tipoDeImovel', $atendimentoContext)
                )->first()->descricao
                : null,
            'latitude' => $this->getFirstNodeValue('latitude', $atendimentoContext),
            'longitude' => $this->getFirstNodeValue('longitude', $atendimentoContext),
            'statusVisitaCompartilhadaOutroProfissional' => DataUtil::getSimOuNao(
                DataUtil::getBooleanValueFromStringBoolean(
                    $this->getFirstNodeValue('statusVisitaCompartilhadaOutroProfissional', $atendimentoContext)
                )
            ),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Turno', fn () => $inconsistencias->turno],
            ['Tipo de imóvel', fn () => $inconsistencias->tipoDeImovel],
            ['Latitude', fn () => $inconsistencias->latitude],
            ['Longitude', fn () => $inconsistencias->longitude],
            ['Visita compartilhada com outro profissional', fn () => $inconsistencias->statusVisitaCompartilhadaOutroProfissional],
        ]);

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

    private function setAvaliacaoAntropometriza($atendimento, $atendimentoContext, $inconsistencias)
    {
        $campos = (object) [
            'pesoAcompanhamentoNutricional' => $this->getFirstNodeValue('pesoAcompanhamentoNutricional', $atendimentoContext),
            'alturaAcompanhamentoNutricional' => $this->getFirstNodeValue('alturaAcompanhamentoNutricional', $atendimentoContext),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Peso', fn () => $inconsistencias->pesoAcompanhamentoNutricional],
            ['Altura', fn () => $inconsistencias->alturaAcompanhamentoNutricional],
        ]);

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

    private function setMotivosVisita($atendimento, $atendimentoContext, $inconsistencias)
    {
        $motivosVisita = [];

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

            $motivoVisita = MotivoVisita::where('codigo_esus', $context->nodeValue)->first();

            $descricao = null;

            if ($this->isMotivoVisitaTipo($motivoVisita->id)) {

                $descricao = 'Tipo de visita';
            }
            else if ($this->isMotivoVisitaBuscaAtiva($motivoVisita->id)) {

                $descricao = 'Busca ativa';
            }
            else if ($this->isMotivoVisitaControleAmbientalVetorial($motivoVisita->id)) {

                $descricao = 'Controle ambiental/vetorial';
            }
            else if ($this->isMotivoVisitaAcompanhamento($motivoVisita->id)) {

                $descricao = 'Acompanhamento';
            }
            else if ($this->isOutroMotivoVisita($motivoVisita->id)) {

                $descricao = 'Outros';
            }

            $motivosVisita[] = "{$descricao}: {$motivoVisita->descricao}";
        }

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

    private function isMotivoVisitaTipo($id)
    {
        return collect([
            MotivoVisitaEnum::CADASTRAMENTO_ATUALIZACAO,
            MotivoVisitaEnum::VISITA_PERIODICA,
        ])->contains($id);
    }

    private function isMotivoVisitaBuscaAtiva($id)
    {
        return collect([
            MotivoVisitaEnum::CONSULTA,
            MotivoVisitaEnum::EXAME,
            MotivoVisitaEnum::VACINA,
            MotivoVisitaEnum::CONDICIONALIDADES_DO_BOLSA_FAMILIA,
        ])->contains($id);
    }

    private function isMotivoVisitaControleAmbientalVetorial($id)
    {
        return collect([
            MotivoVisitaEnum::ACAO_EDUCATIVA,
            MotivoVisitaEnum::IMOVEL_COM_FOCO,
            MotivoVisitaEnum::ACAO_MECANICA,
            MotivoVisitaEnum::TRATAMENTO_FOCAL,
        ])->contains($id);
    }

    private function isMotivoVisitaAcompanhamento($id)
    {
        return collect([
            MotivoVisitaEnum::GESTANTE,
            MotivoVisitaEnum::PUERPERA,
            MotivoVisitaEnum::RECEM_NASCIDO,
            MotivoVisitaEnum::CRIANCA,
            MotivoVisitaEnum::PESSOA_COM_DESNUTRICAO,
            MotivoVisitaEnum::PESSOA_EM_REABILITACAO_OU_COM_DEFICIENCIA,
            MotivoVisitaEnum::PESSOA_COM_HIPERTENSAO,
            MotivoVisitaEnum::PESSOA_COM_DIABETES,
            MotivoVisitaEnum::PESSOA_COM_ASMA,
            MotivoVisitaEnum::PESSOA_COM_DPOC_ENFISEMA,
            MotivoVisitaEnum::PESSOA_COM_CANCER,
            MotivoVisitaEnum::PESSOA_COM_OUTRAS_DOENCAS_CRONICAS,
            MotivoVisitaEnum::PESSOA_COM_HANSENIASE,
            MotivoVisitaEnum::PESSOA_COM_TUBERCULOSE,
            MotivoVisitaEnum::SINTOMATICOS_RESPIRATORIOS,
            MotivoVisitaEnum::TABAGISTA,
            MotivoVisitaEnum::DOMICILIADOS_ACAMADOS,
            MotivoVisitaEnum::CONDICOES_DE_VULNERABILIDADE_SOCIAL,
            MotivoVisitaEnum::ACOMPANHAMENTO_CONDICIONALIDADES_DO_BOLSA_FAMILIA,
            MotivoVisitaEnum::SAUDE_MENTAL,
            MotivoVisitaEnum::USUARIO_DE_ALCOOL,
            MotivoVisitaEnum::USUARIO_DE_OUTRAS_DROGAS,
        ])->contains($id);
    }

    private function isOutroMotivoVisita($id)
    {
        return collect([
            MotivoVisitaEnum::EGRESSO_DE_INTERNACAO,
            MotivoVisitaEnum::CONVITE_PARA_ATIVIDADES_COLETIVAS_CAMPANHA_DE_SAUDE,
            MotivoVisitaEnum::ORIENTACAO_PREVENCAO,
            MotivoVisitaEnum::OUTROS,
        ])->contains($id);
    }

    private function setSinaisVitais($atendimento, $atendimentoContext, $inconsistencias)
    {
        $campos = (object) [
            'pressaoArterial' => trim($this->getFirstNodeValue('pressaoSistolica', $atendimentoContext)
                . '/' . $this->getFirstNodeValue('pressaoDiastolica', $atendimentoContext), '/'),
            'temperatura' => $this->getFirstNodeValue('temperatura', $atendimentoContext),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Aferição de PA sistólica', fn () => $inconsistencias->pressaoSistolica],
            ['Aferição de PA diastólica', fn () => $inconsistencias->pressaoDiastolica],
            ['Temperatura', fn () => $inconsistencias->temperatura],
        ]);

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

    private function setGlicemia($atendimento, $atendimentoContext, $inconsistencias)
    {
        $campos = (object) [
            'glicemia' => $this->getFirstNodeValue('glicemia', $atendimentoContext),
            'tipoGlicemia' => !is_null($this->getFirstNodeValue('tipoGlicemia', $atendimentoContext))
                ? MomentoColeta::where(
                    'codigo_esus',
                    $this->getFirstNodeValue('tipoGlicemia', $atendimentoContext)
                )->first()->descricao
                : null,
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Glicemia', fn () => $inconsistencias->glicemia],
            ['Momento da coleta', fn () => $inconsistencias->tipoGlicemia],
        ]);

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

    private function setDesfecho($atendimento, $atendimentoContext, $inconsistencias)
    {
        $campos = (object) [
            'desfecho' => $this->getFirstNodeValue('desfecho', $atendimentoContext)
                ? Desfecho::where(
                    'codigo_esus',
                    $this->getFirstNodeValue('desfecho', $atendimentoContext)
                )->first()->descricao
                : null,
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Desfecho', fn () => $inconsistencias->desfecho],
        ]);

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