<?php

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

use App\Enums\AtencaoBasica\CadastroDomiciliar\ImovelTipo as CadastroDomiciliarImovelTipo;
use App\Enums\AtencaoBasica\Exportacao\SalarioMinimo;
use App\Models\AtencaoBasica\CadastroDomiciliar\Abastecimento;
use App\Models\AtencaoBasica\CadastroDomiciliar\Animal;
use App\Models\AtencaoBasica\CadastroDomiciliar\DestinoLixo;
use App\Models\AtencaoBasica\CadastroDomiciliar\DomicilioTipo;
use App\Models\AtencaoBasica\CadastroDomiciliar\DomicilioTipoAcesso;
use App\Models\AtencaoBasica\CadastroDomiciliar\FormaEscoamento;
use App\Models\AtencaoBasica\CadastroDomiciliar\ImovelTipo;
use App\Models\AtencaoBasica\CadastroDomiciliar\MaterialPredominante;
use App\Models\AtencaoBasica\CadastroDomiciliar\SituacaoDomicilio;
use App\Models\AtencaoBasica\CadastroDomiciliar\SituacaoRural;
use App\Models\AtencaoBasica\CadastroDomiciliar\Tratamento;
use App\Models\Cadastro\Localizacao\LogradouroTipo;
use App\Models\Cadastro\Localizacao\Zona;
use App\Models\Intranet\Estado;
use App\Models\Sigtap\Ocupacao;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;

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

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

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

        $this->setEndereco($path);
        $this->setRecusaCadastro($path);
        $this->setResidencia($path);
        $this->setProfissional($path);
        $this->setResidentes($path);
        $this->setInstituicaoPermanencia($path);

        return $this->ficha;
    }

    private function setEndereco($cadastroDomiciliarTransportPath)
    {
        $enderecoLocalPermanenciaPath = "{$cadastroDomiciliarTransportPath}/enderecoLocalPermanencia";

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

        $inconsistencias = $this->getInconsistencias([
            ['Latitude', fn () => $this->inconsistencias->latitude],
            ['Longitude', fn () => $this->inconsistencias->longitude],
            ['Bairro', fn () => $this->inconsistencias->enderecoLocalPermanencia->bairro],
            ['CEP', fn () => $this->inconsistencias->enderecoLocalPermanencia->cep],
            ['IBGE', fn () => $this->inconsistencias->enderecoLocalPermanencia->codigoIbgeMunicipio],
            ['Complemento', fn () => $this->inconsistencias->enderecoLocalPermanencia->complemento],
            ['Logradouro', fn () => $this->inconsistencias->enderecoLocalPermanencia->nomeLogradouro],
            ['Número', fn () => $this->inconsistencias->enderecoLocalPermanencia->numero],
            ['UF', fn () => $this->inconsistencias->enderecoLocalPermanencia->numeroDneUf],
            ['Telefone', fn () => $this->inconsistencias->enderecoLocalPermanencia->telefoneContato],
            ['Tipo de logradouro', fn () => $this->inconsistencias->enderecoLocalPermanencia->tipoLogradouroNumeroDne],
            ['Sem número', fn () => $this->inconsistencias->enderecoLocalPermanencia->stSemNumero],
            ['Ponto de referência', fn () => $this->inconsistencias->enderecoLocalPermanencia->pontoReferencia],
            ['Microárea', fn () => $this->inconsistencias->enderecoLocalPermanencia->microArea],
            ['Fora de área', fn () => $this->inconsistencias->enderecoLocalPermanencia->stForaArea],
        ]);

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

    private function setRecusaCadastro($cadastroDomiciliarTransportPath)
    {
        $path = $cadastroDomiciliarTransportPath;

        $campos = (object) [
            'statusTermoRecusa' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue("{$path}/statusTermoRecusa"))),
        ];

        $inconsistencias = $this->getInconsistencias([
            [
                'Usuário recusou o cadastro por meio do termo de Recusa do Cadastro',
                fn () => $this->inconsistencias->statusTermoRecusa
            ],
        ]);

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

    private function setResidencia($cadastroDomiciliarTransportPath)
    {
        $condicaoMoradiaPath = "{$cadastroDomiciliarTransportPath}/condicaoMoradia";

        $tipoImovel = $this->getFirstNodeValue("{$cadastroDomiciliarTransportPath}/tipoDeImovel")
            ? ImovelTipo::where('codigo_esus', $this->getFirstNodeValue("{$cadastroDomiciliarTransportPath}/tipoDeImovel"))
                ->first()
            : null;

        $campos = (object) [
            'showInstituicaoPermanencia' => collect([
                CadastroDomiciliarImovelTipo::ABRIGO,
                CadastroDomiciliarImovelTipo::INSTITUICAO_LONGA_PERMANENCIA_IDOSOS,
                CadastroDomiciliarImovelTipo::UNIDADE_PRISIONAL,
                CadastroDomiciliarImovelTipo::UNIDADE_MEDIDA_SOCIO_EDUCATIVA,
                CadastroDomiciliarImovelTipo::DELEGACIA
            ])->contains($tipoImovel->id ?? null),
            'showResidentes' => ($tipoImovel->id ?? null) === CadastroDomiciliarImovelTipo::DOMICILIO,
            'tipoDeImovel' => $tipoImovel->descricao ?? null,
            'quantosAnimaisNoDomicilio' => $this->getFirstNodeValue("{$cadastroDomiciliarTransportPath}/quantosAnimaisNoDomicilio"),
            'stAnimaisNoDomicilio' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue("{$cadastroDomiciliarTransportPath}/stAnimaisNoDomicilio"))),
            'abastecimentoAgua' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/abastecimentoAgua")
                ? Abastecimento::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/abastecimentoAgua"))
                    ->first()->descricao
                : null,
            'areaProducaoRural' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/areaProducaoRural")
                ? SituacaoRural::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/areaProducaoRural"))
                    ->first()->descricao
                : null,
            'destinoLixo' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/destinoLixo")
                ? DestinoLixo::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/destinoLixo"))
                    ->first()->descricao
                : null,
            'formaEscoamentoBanheiro' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/formaEscoamentoBanheiro")
                ? FormaEscoamento::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/formaEscoamentoBanheiro"))
                    ->first()->descricao
                : null,
            'localizacao' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/localizacao")
                ? Zona::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/localizacao"))->first()->descricao
                : null,
            'materialPredominanteParedesExtDomicilio' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/materialPredominanteParedesExtDomicilio")
                ? MaterialPredominante::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/materialPredominanteParedesExtDomicilio"))
                    ->first()->descricao
                : null,
            'nuComodos' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/nuComodos"),
            'nuMoradores' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/nuMoradores"),
            'situacaoMoradiaPosseTerra' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/situacaoMoradiaPosseTerra")
                ? SituacaoDomicilio::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/situacaoMoradiaPosseTerra"))
                    ->first()->descricao
                : null,
            'stDisponibilidadeEnergiaEletrica' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue("{$condicaoMoradiaPath}/stDisponibilidadeEnergiaEletrica"))),
            'tipoAcessoDomicilio' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/tipoAcessoDomicilio")
                ? DomicilioTipoAcesso::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/tipoAcessoDomicilio"))
                    ->first()->descricao
                : null,
            'tipoDomicilio' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/tipoDomicilio")
                ? DomicilioTipo::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/tipoDomicilio"))
                    ->first()->descricao
                : null,
            'aguaConsumoDomicilio' => $this->getFirstNodeValue("{$condicaoMoradiaPath}/aguaConsumoDomicilio")
                ? Tratamento::where('codigo_esus', $this->getFirstNodeValue("{$condicaoMoradiaPath}/aguaConsumoDomicilio"))
                    ->first()->descricao
                : null,
        ];

        $animaisNoDomicilio = [];

        foreach ($this->domx->query("{$cadastroDomiciliarTransportPath}/animaisNoDomicilio") as $context) {

            $animaisNoDomicilio[] = Animal::where('codigo_esus', $context->nodeValue)->first()->descricao;
        }

        $campos->animaisNoDomicilio = collect($animaisNoDomicilio)->join(', ');

        $inconsistencias = $this->getInconsistencias([
            ['Tipo do imóvel', fn () => $this->inconsistencias->tipoDeImovel],
            ['Animais', fn () => $this->inconsistencias->animaisNoDomicilio],
            ['Quantidade', fn () => $this->inconsistencias->quantosAnimaisNoDomicilio],
            ['Possui animais?', fn () => $this->inconsistencias->stAnimaisNoDomicilio],
            ['Abastecimento de água', fn () => $this->inconsistencias->condicaoMoradia->abastecimentoAgua],
            ['Situação rural', fn () => $this->inconsistencias->condicaoMoradia->areaProducaoRural],
            ['Destino do lixo', fn () => $this->inconsistencias->condicaoMoradia->destinoLixo],
            ['Forma de escoamento sanitário', fn () => $this->inconsistencias->condicaoMoradia->formaEscoamentoBanheiro],
            ['Zona', fn () => $this->inconsistencias->condicaoMoradia->localizacao],
            ['Material predominante - paredes externas', fn () => $this->inconsistencias->condicaoMoradia->materialPredominanteParedesExtDomicilio],
            ['Cômodos', fn () => $this->inconsistencias->condicaoMoradia->nuComodos],
            ['Moradores', fn () => $this->inconsistencias->condicaoMoradia->nuMoradores],
            ['Situação', fn () => $this->inconsistencias->condicaoMoradia->situacaoMoradiaPosseTerra],
            ['Disponibilidade de energia elétrica', fn () => $this->inconsistencias->condicaoMoradia->stDisponibilidadeEnergiaEletrica],
            ['Tipo de acesso ao domicílio', fn () => $this->inconsistencias->condicaoMoradia->tipoAcessoDomicilio],
            ['Tipo de domicílio', fn () => $this->inconsistencias->condicaoMoradia->tipoDomicilio],
            ['Tratamento de água', fn () => $this->inconsistencias->condicaoMoradia->aguaConsumoDomicilio],
        ]);

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

    private function setProfissional($cadastroDomiciliarTransportPath)
    {
        $headerTransportPath = "{$cadastroDomiciliarTransportPath}/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->cadastroDomiciliar->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 setResidentes($cadastroDomiciliarTransportPath)
    {
        $path = "{$cadastroDomiciliarTransportPath}/familias";

        $residentes = [];

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

            $posicao = $i + 1;

            $paciente = $this->inconsistenciaModel->cadastroDomiciliarPacientes()
                ->wherePivot('posicao', $posicao)
                ->first();

            $residentes[] = (object) [
                'nome' => $paciente->cidadao->nome,
                'dataNascimentoResponsavel' => $this->getDateString($this->getFirstNodeValue('dataNascimentoResponsavel', $context)),
                'numeroCnsResponsavel' => MaskUtil::getCnsMasked($this->getFirstNodeValue('numeroCnsResponsavel', $context)),
                'cpfResponsavel' => MaskUtil::getCpfMasked($this->getFirstNodeValue('cpfResponsavel', $context)),
                'numeroMembrosFamilia' => $this->getFirstNodeValue('numeroMembrosFamilia', $context),
                'numeroProntuario' => $this->getFirstNodeValue('numeroProntuario', $context),
                'rendaFamiliar' => $this->getRendaFamiliar($this->getFirstNodeValue('rendaFamiliar', $context)),
            ];
        }

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

    private function getRendaFamiliar($rendaId)
    {
        switch ($rendaId) {

            case SalarioMinimo::UM_QUARTO_SALARIO_MINIMO: {

                return 'Um quarto do salário mínimo';
            }
            case SalarioMinimo::MEIO_SALARIO_MINIMO: {

                return 'Meio salário mínimo';
            }
            case SalarioMinimo::UM_QUARTO_SALARIO_MINIMO: {

                return 'Um quarto do salário mínimo';
            }
            case SalarioMinimo::DOIS_SALARIO_MINIMO: {

                return 'Dois salários mínimos';
            }
            case SalarioMinimo::TRES_SALARIO_MINIMO: {

                return 'Três salários mínimos';
            }
            case SalarioMinimo::QUATRO_SALARIO_MINIMO: {

                return 'Quatro salários mínimos';
            }
            case SalarioMinimo::ACIMA_QUATRO_SALARIO_MINIMO: {

                return 'Acima de quatro salários mínimos';
            }
            default: {

                return null;
            }
        }
    }

    private function setInstituicaoPermanencia($cadastroDomiciliarTransportPath)
    {
        $path = "{$cadastroDomiciliarTransportPath}/instituicaoPermanencia";

        $campos = (object) [
            'nomeInstituicaoPermanencia' => $this->getFirstNodeValue("{$path}/nomeInstituicaoPermanencia"),
            'stOutrosProfissionaisVinculados' => DataUtil::getSimOuNao(DataUtil::getBooleanValueFromStringBoolean(
                $this->getFirstNodeValue("{$path}/stOutrosProfissionaisVinculados"))),
        ];

        $inconsistencias = $this->getInconsistencias([
            [
                'Nome da instituição de permanência',
                fn () => $this->inconsistencias->instituicaoPermanencia->nomeInstituicaoPermanencia
            ],
            [
                'Existem outros profissionais de saúde vinculados à instituição (não inclui profissionais da rede pública de saúde)?',
                fn () => $this->inconsistencias->instituicaoPermanencia->stOutrosProfissionaisVinculados
            ],
        ]);

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

        $this->setIdentificacaoResponsavelTecnico($path);
    }

    private function setIdentificacaoResponsavelTecnico($instituicaoPermanenciaPath)
    {
        $path = $instituicaoPermanenciaPath;

        $campos = (object) [
            'nomeResponsavelTecnico' => $this->getFirstNodeValue("{$path}/nomeResponsavelTecnico"),
            'cnsResponsavelTecnico' => MaskUtil::getCnsMasked($this->getFirstNodeValue("{$path}/cnsResponsavelTecnico")),
            'cargoInstituicao' => $this->getFirstNodeValue("{$path}/cargoInstituicao"),
            'telefoneResponsavelTecnico' => MaskUtil::getPhoneMasked($this->getFirstNodeValue("{$path}/telefoneResponsavelTecnico")),
        ];

        $inconsistencias = $this->getInconsistencias([
            [
                'Responsável técnico pela instituição',
                fn () => $this->inconsistencias->instituicaoPermanencia->nomeResponsavelTecnico
            ],
            [
                'CNS do responsável',
                fn () => $this->inconsistencias->instituicaoPermanencia->cnsResponsavelTecnico
            ],
            [
                'Cargo na instituição',
                fn () => $this->inconsistencias->instituicaoPermanencia->cargoInstituicao
            ],
            [
                'Telefone de contato',
                fn () => $this->inconsistencias->instituicaoPermanencia->telefoneResponsavelTecnico
            ],
        ]);

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