<?php

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

use App\Enums\AtencaoBasica\Avaliacao\Conclusao as AvaliacaoConclusao;
use App\Enums\AtencaoBasica\Avaliacao\Cuidador as AvaliacaoCuidador;
use App\Models\AtencaoBasica\Avaliacao\Conclusao;
use App\Models\AtencaoBasica\Avaliacao\CondicaoAvaliada;
use App\Models\AtencaoBasica\Avaliacao\Cuidador;
use App\Models\AtencaoBasica\Avaliacao\JustificativaConclusao;
use App\Models\AtencaoBasica\Avaliacao\Procedencia;
use App\Models\Cadastro\Localizacao\LogradouroTipo;
use App\Models\Cadastro\SujeitoAtencao\EtniaIndigena;
use App\Models\Cadastro\SujeitoAtencao\Nacionalidade;
use App\Models\Cadastro\SujeitoAtencao\RacaCor;
use App\Models\Geral\Turno;
use App\Models\Intranet\Estado;
use App\Models\Intranet\Pais;
use App\Models\Sigtap\Cid;
use App\Models\Sigtap\Ocupacao;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;

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

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

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

        $this->setPaciente($path);
        $this->setProfissional($path);
        $this->setCondicoesAvalidas($path);
        $this->setCid($path);
        $this->setConclusao($path);
        $this->setCuidador($path);

        return $this->ficha;
    }

    private function setPaciente($fichaAvaliacaoElegibilidadeTransportPath)
    {
        $path = $fichaAvaliacaoElegibilidadeTransportPath;

        $campos = (object) [
            'cnsCidadao' => MaskUtil::getCnsMasked($this->getFirstNodeValue("{$path}/cnsCidadao")),
            'cpfCidadao' => MaskUtil::getCpfMasked($this->getFirstNodeValue("{$path}/cpfCidadao")),
            'dataNascimentoCidadao' => $this->getDateString($this->getFirstNodeValue("{$path}/dataNascimentoCidadao")),
            'sexoCidadao' => $this->getSexo($this->getFirstNodeValue("{$path}/sexoCidadao")),
            'nomeCidadao' => $this->getFirstNodeValue("{$path}/nomeCidadao"),
            'racaCorCidadao' => $this->getFirstNodeValue("{$path}/racaCorCidadao")
                ? RacaCor::where('codigo_esus', $this->getFirstNodeValue("{$path}/racaCorCidadao"))->first()->descricao
                : null,
            'nomeSocialCidadao' => $this->getFirstNodeValue("{$path}/nomeSocialCidadao"),
            'nomeMaeCidadao' => $this->getFirstNodeValue("{$path}/nomeMaeCidadao"),
            'desconheceNomeMae' => DataUtil::getSimOuNao(
                DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue("{$path}/desconheceNomeMae"))),
            'codigoIbgeMunicipioNascimento' => $this->getFirstNodeValue("{$path}/codigoIbgeMunicipioNascimento"),
            'nacionalidadeCidadao' => $this->getFirstNodeValue("{$path}/nacionalidadeCidadao")
                ? Nacionalidade::where(
                    'codigo_esus',
                    $this->getFirstNodeValue("{$path}/nacionalidadeCidadao")
                )->first()->descricao
                : null,
            'emailCidadao' => $this->getFirstNodeValue("{$path}/emailCidadao"),
            'numeroNisPisPasep' => $this->getFirstNodeValue("{$path}/numeroNisPisPasep"),
            'nomePaiCidadao' => $this->getFirstNodeValue("{$path}/nomePaiCidadao"),
            'desconheceNomePai' => DataUtil::getSimOuNao(
                DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue("{$path}/desconheceNomePai"))),
            'dtNaturalizacao' => $this->getDateString($this->getFirstNodeValue("{$path}/dtNaturalizacao")),
            'portariaNaturalizacao' => $this->getFirstNodeValue("{$path}/portariaNaturalizacao"),
            'dtEntradaBrasil' => $this->getDateString($this->getFirstNodeValue("{$path}/dtEntradaBrasil")),
            'paisNascimento' => $this->getFirstNodeValue("{$path}/paisNascimento")
                ? Pais::where('codigo_esus', $this->getFirstNodeValue("{$path}/paisNascimento"))->first()->nome
                : null,
            'etnia' => $this->getFirstNodeValue("{$path}/etnia")
                ? EtniaIndigena::where('codigo_cadsus', $this->getFirstNodeValue("{$path}/etnia"))->first()->descricao
                : null,
        ];

        $inconsistencias = $this->getInconsistencias([
            ['CNS', fn () => $this->inconsistencias->cnsCidadao],
            ['CPF', fn () => $this->inconsistencias->cpfCidadao],
            ['Data de nascimento', fn () => $this->inconsistencias->dataNascimentoCidadao],
            ['Sexo', fn () => $this->inconsistencias->sexoCidadao],
            ['Nome', fn () => $this->inconsistencias->nomeCidadao],
            ['Raça/cor', fn () => $this->inconsistencias->racaCorCidadao],
            ['Nome social', fn () => $this->inconsistencias->nomeSocialCidadao],
            ['Nome da mãe', fn () => $this->inconsistencias->nomeMaeCidadao],
            ['Desconhece mãe', fn () => $this->inconsistencias->desconheceNomeMae],
            ['IBGE (Nascimento)', fn () => $this->inconsistencias->codigoIbgeMunicipioNascimento],
            ['Nacionalidade', fn () => $this->inconsistencias->nacionalidadeCidadao],
            ['E-mail', fn () => $this->inconsistencias->emailCidadao],
            ['PIS / PASEP | NIS', fn () => $this->inconsistencias->numeroNisPisPasep],
            ['Nome do pai', fn () => $this->inconsistencias->nomePaiCidadao],
            ['Desconhece pai', fn () => $this->inconsistencias->desconheceNomePai],
            ['Data de naturalização', fn () => $this->inconsistencias->dtNaturalizacao],
            ['Portaria de naturalização', fn () => $this->inconsistencias->portariaNaturalizacao],
            ['Data de entrada no Brasil', fn () => $this->inconsistencias->dtEntradaBrasil],
            ['País de nascimento', fn () => $this->inconsistencias->paisNascimento],
            ['Etnia', fn () => $this->inconsistencias->etnia],
        ]);

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

        $this->setPacienteEndereco($path);
    }

    private function setPacienteEndereco($fichaAvaliacaoElegibilidadeTransportPath)
    {
        $path = "{$fichaAvaliacaoElegibilidadeTransportPath}/endereco";

        $campos = (object) [
            'bairro' => $this->getFirstNodeValue("{$path}/bairro"),
            'cep' => MaskUtil::getCepMasked($this->getFirstNodeValue("{$path}/cep")),
            'codigoIbgeMunicipio' => $this->getFirstNodeValue("{$path}/codigoIbgeMunicipio"),
            'complemento' => $this->getFirstNodeValue("{$path}/complemento"),
            'nomeLogradouro' => $this->getFirstNodeValue("{$path}/nomeLogradouro"),
            'numero' => $this->getFirstNodeValue("{$path}/numero"),
            'numeroDneUf' => $this->getFirstNodeValue("{$path}/numeroDneUf")
                ? Estado::where('codigo', $this->getFirstNodeValue("{$path}/numeroDneUf"))->first()->uf
                : null,
            'telefoneContato' => MaskUtil::getPhoneMasked($this->getFirstNodeValue("{$path}/telefoneContato")),
            'tipoLogradouroNumeroDne' => $this->getFirstNodeValue("{$path}/tipoLogradouroNumeroDne")
                ? LogradouroTipo::where(
                    'codigo',
                    $this->getFirstNodeValue("{$path}/tipoLogradouroNumeroDne")
                )->first()->descricao
                : null,
            'stSemNumero' => DataUtil::getSimOuNao(
                DataUtil::getBooleanValueFromStringBoolean($this->getFirstNodeValue("{$path}/stSemNumero"))),
            'pontoReferencia' => $this->getFirstNodeValue("{$path}/pontoReferencia"),
        ];

        $inconsistencias = $this->getInconsistencias([
            fn () => $this->inconsistencias->endereco,
            ['Bairro', fn () => $this->inconsistencias->endereco->bairro],
            ['CEP', fn () => $this->inconsistencias->endereco->cep],
            ['IBGE', fn () => $this->inconsistencias->endereco->codigoIbgeMunicipio],
            ['Complemento', fn () => $this->inconsistencias->endereco->complemento],
            ['Logradouro', fn () => $this->inconsistencias->endereco->nomeLogradouro],
            ['Número', fn () => $this->inconsistencias->endereco->numero],
            ['UF', fn () => $this->inconsistencias->endereco->numeroDneUf],
            ['Telefone', fn () => $this->inconsistencias->endereco->telefoneContato],
            ['Tipo de logradouro', fn () => $this->inconsistencias->endereco->tipoLogradouroNumeroDne],
            ['Sem número', fn () => $this->inconsistencias->endereco->stSemNumero],
            ['Ponto de referência', fn () => $this->inconsistencias->endereco->pontoReferencia],
        ]);

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

    private function setProfissional($fichaAvaliacaoElegibilidadeTransportPath)
    {
        $headerTransportPath = "{$fichaAvaliacaoElegibilidadeTransportPath}/headerTransport";
        $lotacaoFormPrincipalPath = "{$headerTransportPath}/lotacaoFormPrincipal";

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

        $campos = (object) [
            'turno' => $this->getFirstNodeValue("{$fichaAvaliacaoElegibilidadeTransportPath}/turno")
                ? Turno::find($this->getFirstNodeValue("{$fichaAvaliacaoElegibilidadeTransportPath}/turno"))->nome
                : null,
            'atencaoDomiciliarProcedencia' => $this->getFirstNodeValue("{$fichaAvaliacaoElegibilidadeTransportPath}/atencaoDomiciliarProcedencia")
                ? Procedencia::find($this->getFirstNodeValue("{$fichaAvaliacaoElegibilidadeTransportPath}/atencaoDomiciliarProcedencia"))->descricao
                : null,
            'dataAtendimento' => $this->getDateString($this->getFirstNodeValue("{$headerTransportPath}/dataAtendimento")),
            'codigoIbgeMunicipio' => $this->getFirstNodeValue("{$headerTransportPath}/codigoIbgeMunicipio"),
            'profissionalNome' => $this->inconsistenciaModel->avaliacao->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([
            ['Turno', fn () => $this->inconsistencias->turno],
            ['Procedência', fn () => $this->inconsistencias->atencaoDomiciliarProcedencia],
            ['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 = (object) compact('campos', 'inconsistencias');
    }

    private function setCondicoesAvalidas($fichaAvaliacaoElegibilidadeTransportPath)
    {
        $path = "{$fichaAvaliacaoElegibilidadeTransportPath}/condicoesAvaliadas";

        $condicoesAvaliadas = [];

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

            $condicoesAvaliadas[] = CondicaoAvaliada::find($context->nodeValue)->descricao;
        }

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

    private function setCid($fichaAvaliacaoElegibilidadeTransportPath)
    {
        $path = $fichaAvaliacaoElegibilidadeTransportPath;

        $cidPrincipal = $this->getFirstNodeValue("{$path}/cid10Principal")
            ? Cid::where('codigo', $this->getFirstNodeValue("{$path}/cid10Principal"))->first()
            : null;

        $cidSecundarioUm = $this->getFirstNodeValue("{$path}/cid10SecundarioUm")
            ? Cid::where('codigo', $this->getFirstNodeValue("{$path}/cid10SecundarioUm"))->first()
            : null;

        $cidSecundarioDois = $this->getFirstNodeValue("{$path}/cid10SecundarioDois")
            ? Cid::where('codigo', $this->getFirstNodeValue("{$path}/cid10SecundarioDois"))->first()
            : null;

        $campos = (object) [
            'cid10Principal' => $cidPrincipal
                ? MaskUtil::getCidMasked($cidPrincipal->codigo) . " - {$cidPrincipal->nome}"
                : null,
            'cid10SecundarioUm' => $cidSecundarioUm
                ? MaskUtil::getCidMasked($cidSecundarioUm->codigo) . " - {$cidSecundarioUm->nome}"
                : null,
            'cid10SecundarioDois' => $cidSecundarioDois
                ? MaskUtil::getCidMasked($cidSecundarioDois->codigo) . " - {$cidSecundarioDois->nome}"
                : null,
        ];

        $inconsistencias = $this->getInconsistencias([
            ['CID Primário', fn () => $this->inconsistencias->cid10Principal],
            ['CID Secundário', fn () => $this->inconsistencias->cid10SecundarioUm],
            ['CID Terciário', fn () => $this->inconsistencias->cid10SecundarioDois],
        ]);

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

    private function setConclusao($fichaAvaliacaoElegibilidadeTransportPath)
    {
        $path = $fichaAvaliacaoElegibilidadeTransportPath;

        $conclusao = $this->getFirstNodeValue("{$path}/atencaoDomiciliarModalidade")
            ? Conclusao::find($this->getFirstNodeValue("{$path}/atencaoDomiciliarModalidade"))
            : null;

        $campos = (object) [
            'atencaoDomiciliarModalidade' => $conclusao->descricao ?? null,
            'elegivel' => ($conclusao->id ?? null) !== AvaliacaoConclusao::INELEGIVEL,
            'conclusaoDestinoInelegivel' => $this->getFirstNodeValue("{$path}/conclusaoDestinoInelegivel")
                ? JustificativaConclusao::where(
                    'codigo',
                    $this->getFirstNodeValue("{$path}/conclusaoDestinoInelegivel")
                )->first()->descricao
                : null,
            'conclusaoDestinoElegivel' => $this->getFirstNodeValue("{$path}/conclusaoDestinoElegivel")
                ? JustificativaConclusao::where(
                    'codigo',
                    $this->getFirstNodeValue("{$path}/conclusaoDestinoElegivel")
                )->first()->descricao
                : null,
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Conclusão', fn () => $this->inconsistencias->atencaoDomiciliarModalidade],
            fn () => $this->inconsistencias->conclusaoDestinoInelegivel,
            fn () => $this->inconsistencias->conclusaoDestinoElegivel,
        ]);

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

    private function setCuidador($fichaAvaliacaoElegibilidadeTransportPath)
    {
        $path = $fichaAvaliacaoElegibilidadeTransportPath;

        $cuidador = $this->getFirstNodeValue("{$path}/cuidadorCidadao")
            ? Cuidador::find($this->getFirstNodeValue("{$path}/cuidadorCidadao"))
            : null;

        $campos = (object) [
            'cuidadorCidadao' => $cuidador->descricao ?? null,
            'possuiCuidador' => ($cuidador->id ?? null) !== AvaliacaoCuidador::NAO_POSSUI,
            'cnsCuidador' => MaskUtil::getCnsMasked($this->getFirstNodeValue("{$path}/cnsCuidador")),
            'cpfCuidador' => MaskUtil::getCpfMasked($this->getFirstNodeValue("{$path}/cpfCuidador")),
        ];

        $inconsistencias = $this->getInconsistencias([
            ['Cuidador', fn () => $this->inconsistencias->cuidadorCidadao],
            ['CNS', fn () => $this->inconsistencias->cnsCuidador],
            ['CPF', fn () => $this->inconsistencias->cpfCuidador],
        ]);

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