<?php

namespace App\Services\Integracao;

use App\Enums\Integracao\Esus\Origem;
use App\Models\AtencaoBasica\AtendimentoDomiciliar\AtendimentoDomiciliar;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividual;
use App\Models\AtencaoBasica\AtendimentoOdontologico\AtendimentoOdontologico;
use App\Models\AtencaoBasica\AtividadeColetiva\AtividadeColetiva;
use App\Models\AtencaoBasica\Avaliacao\Avaliacao;
use App\Models\AtencaoBasica\CadastroDomiciliar\CadastroDomiciliar;
use App\Models\AtencaoBasica\CadastroIndividual\CadastroIndividual;
use App\Models\AtencaoBasica\Exportacao\Exportacao;
use App\Models\AtencaoBasica\FichaComplementar\FichaComplementar;
use App\Models\AtencaoBasica\FichaVacinacao\FichaVacinacao;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentar;
use App\Models\AtencaoBasica\Procedimento\Procedimento;
use App\Models\AtencaoBasica\VisitaDomiciliar\VisitaDomiciliar;
use App\Models\Integracao\Esus\Inconsistencia;
use App\Services\Service;
use Exception;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

class EsusService extends Service
{
    public const INCONSISTENCIA_XML_ENVIO_PATH = 'integracao'
        . DIRECTORY_SEPARATOR
        . 'esus'
        . DIRECTORY_SEPARATOR
        . 'inconsistencia'
        . DIRECTORY_SEPARATOR
        . 'xml-envio';

    public static function getAuthorizationCookie($parametrizacao)
    {
        $response = Http::asMultipart()
            ->post("{$parametrizacao->url_instalacao}/api/recebimento/login", [
                'usuario' => $parametrizacao->usuario,
                'senha' => $parametrizacao->senha,
            ]);

        if ($response->successful()) {

            return $response->header('Set-Cookie');
        }

        throw new Exception('Erro ao obter o cookie de autorização.'
            . (!empty($response->body()) ? " ({$response->body()})" : ''));
    }

    public static function deleteInconsistencias($cliente, $nomeFicha)
    {
        Inconsistencia::where('origem_id', self::getOrigemId($nomeFicha))
            ->get()
            ->each(function ($inconsistencia) use ($cliente) {

                Storage::disk('local')->delete(self::INCONSISTENCIA_XML_ENVIO_PATH
                    . DIRECTORY_SEPARATOR . $cliente
                    . DIRECTORY_SEPARATOR . "{$inconsistencia->id}.xml");

                $inconsistencia->delete();
            });
    }

    public static function sendFicha($cliente, $parametrizacao, $nomeFicha, $ficha)
    {
        $response = Http::withHeaders(['Cookie' => $parametrizacao->cookie])
            ->attach('ficha', $ficha['xml']['conteudo'], $ficha['xml']['nome_arquivo'])
            ->post("{$parametrizacao->url_instalacao}/api/v1/recebimento/ficha");
    
        if ($response->successful()) {

            return;
        }

        $origemId = self::getOrigemId($nomeFicha);
        self::deleteExportacao($origemId, $ficha['exportacao_id']);

        if ($response->clientError()) {
            
            $dadosResposta = $response->json();
            
            if (isset($dadosResposta['descricaoErro']) && $dadosResposta['descricaoErro'] === 'Erro de validação') {
                
                self::saveInconsistencia($cliente, $origemId, $ficha, $dadosResposta['errosValidacao']);
                return;

            }
            else if(
                isset($dadosResposta['descricaoErro']) &&
                Str::contains($dadosResposta['descricaoErro'], 'versão') &&
                Str::contains($dadosResposta['descricaoErro'], 'inexistente')
            ) {
                self::saveInconsistencia($cliente, $origemId, $ficha, $dadosResposta);
                return;
            }
        }

        throw new Exception("Erro ao enviar a ficha." . (!empty($response->body()) ? " ({$response->body()})" : ''));
    }

    private static function deleteExportacao($origemId, $exportacaoId)
    {
        switch ($origemId) {

            case Origem::ATENDIMENTO_INDIVIDUAL: {

                AtendimentoIndividual::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::ATENDIMENTO_DOMICILIAR: {

                AtendimentoDomiciliar::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::ATENDIMENTO_ODONTOLOGICO: {

                AtendimentoOdontologico::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::ATIVIDADE_COLETIVA: {

                AtividadeColetiva::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::AVALIACAO: {

                Avaliacao::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::PROCEDIMENTO: {

                Procedimento::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::VISITA_DOMICILIAR: {

                VisitaDomiciliar::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::FICHA_VACINACAO: {

                FichaVacinacao::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::FICHA_COMPLEMENTAR: {

                FichaComplementar::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::CADASTRO_DOMICILIAR: {

                CadastroDomiciliar::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::CADASTRO_INDIVIDUAL: {

                CadastroIndividual::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
            case Origem::CONSUMO_ALIMENTAR: {

                MarcadorConsumoAlimentar::where('exportacao_id', $exportacaoId)->update([
                    'exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'usuario_exportacao_id' => null,
                ]);

                break;
            }
        }

        Exportacao::where('id', $exportacaoId)->delete();
    }

    private static function saveInconsistencia($cliente, $origemId, $ficha, $errosValidacao)
    {
        $dadosSerializado = $errosValidacao['dadoSerializado'] ?? null;

        if(!empty($dadosSerializado)){
            $inconsistencia = $dadosSerializado;  

        }
        else if(
            Str::contains($errosValidacao['descricaoErro'], 'versão') &&
            Str::contains($errosValidacao['descricaoErro'], 'inexistente')
        ) {

            $inconsistencia = $errosValidacao;
        }
        
        $dadosInconsistencia = [
            'origem_id' => $origemId,
            'data_atendimento' => $ficha['data_atendimento'],
            'usuario_id' => $ficha['usuario_id'],
            'ocupacao_id' => $ficha['ocupacao_id'],
            'equipe_id' => $ficha['equipe_id'],
            'inconsistencia' => json_encode($inconsistencia),
        ];

        switch ($origemId) {

            case Origem::ATENDIMENTO_INDIVIDUAL: {

                $inconsistencia = Inconsistencia::create($dadosInconsistencia);

                $atendimentosIndividuais = [];

                $ficha['atendimentos_individuais']->each(function ($atendimento) use (&$atendimentosIndividuais) {

                    $atendimentosIndividuais[$atendimento['id']] = [
                        'posicao' => $atendimento['posicao']
                    ];
                });

                $inconsistencia->atendimentosIndividuais()->sync($atendimentosIndividuais);

                break;
            }
            case Origem::ATENDIMENTO_DOMICILIAR: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'atendimento_domiciliar_id' => $ficha['atendimento_domiciliar_id']
                ]));

                $atendimentoDomiciliarAtendimentos = [];

                $ficha['atendimento_domiciliar_atendimentos']->each(function ($atendimento) use (&$atendimentoDomiciliarAtendimentos) {

                    $atendimentoDomiciliarAtendimentos[$atendimento['id']] = [
                        'posicao' => $atendimento['posicao']
                    ];
                });

                $inconsistencia->atendimentoDomiciliarAtendimentos()->sync($atendimentoDomiciliarAtendimentos);

                break;
            }
            case Origem::ATENDIMENTO_ODONTOLOGICO: {

                $inconsistencia = Inconsistencia::create($dadosInconsistencia);

                $atendimentosOdontologicos = [];

                $ficha['atendimentos_odontologicos']->each(function ($atendimento) use (&$atendimentosOdontologicos) {

                    $atendimentosOdontologicos[$atendimento['id']] = [
                        'posicao' => $atendimento['posicao']
                    ];
                });

                $inconsistencia->atendimentosOdontologicos()->sync($atendimentosOdontologicos);

                break;
            }
            case Origem::ATIVIDADE_COLETIVA: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'atividade_coletiva_id' => $ficha['atividade_coletiva_id']
                ]));

                $atividadeColetivaParticipantes = [];

                $ficha['atividade_coletiva_participantes']->each(function ($participante) use (&$atividadeColetivaParticipantes) {

                    $atividadeColetivaParticipantes[$participante['id']] = [
                        'posicao' => $participante['posicao']
                    ];
                });

                $inconsistencia->atividadeColetivaParticipantes()->sync($atividadeColetivaParticipantes);

                break;
            }
            case Origem::AVALIACAO: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'avaliacao_id' => $ficha['avaliacao_id']
                ]));

                break;
            }
            case Origem::PROCEDIMENTO: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'procedimento_id' => $ficha['procedimento_id']
                ]));

                $procedimentoAtendimentos = [];

                $ficha['procedimento_atendimentos']->each(function ($atendimento) use (&$procedimentoAtendimentos) {

                    $procedimentoAtendimentos[$atendimento['id']] = [
                        'posicao' => $atendimento['posicao']
                    ];
                });

                $inconsistencia->procedimentoAtendimentos()->sync($procedimentoAtendimentos);

                break;
            }
            case Origem::VISITA_DOMICILIAR: {

                $inconsistencia = Inconsistencia::create($dadosInconsistencia);

                $visitasDomiciliares = [];

                $ficha['visitas_domiciliares']->each(function ($atendimento) use (&$visitasDomiciliares) {

                    $visitasDomiciliares[$atendimento['id']] = [
                        'posicao' => $atendimento['posicao']
                    ];
                });


                $inconsistencia->visitasDomiciliares()->sync($visitasDomiciliares);

                break;
            }
            case Origem::FICHA_VACINACAO: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'ficha_vacinacao_id' => $ficha['ficha_vacinacao_id']
                ]));

                $fichaVacinacaoPacientes = [];

                $ficha['ficha_vacinacao_pacientes']->each(function ($atendimento) use (&$fichaVacinacaoPacientes) {

                    $fichaVacinacaoPacientes[$atendimento['id']] = [
                        'posicao' => $atendimento['posicao']
                    ];
                });

                $inconsistencia->fichaVacinacaoPacientes()->sync($fichaVacinacaoPacientes);

                break;
            }
            case Origem::FICHA_COMPLEMENTAR: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'ficha_complementar_id' => $ficha['ficha_complementar_id']
                ]));

                break;
            }
            case Origem::CADASTRO_DOMICILIAR: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'cadastro_domiciliar_id' => $ficha['cadastro_domiciliar_id']
                ]));

                $cadastroDomiciliarPacientes = [];

                $ficha['pacientes']->each(function ($paciente) use (&$cadastroDomiciliarPacientes) {

                    $cadastroDomiciliarPacientes[$paciente['id']] = [
                        'posicao' => $paciente['posicao']
                    ];
                });

                $inconsistencia->cadastroDomiciliarPacientes()->sync($cadastroDomiciliarPacientes);

                break;
            }
            case Origem::CADASTRO_INDIVIDUAL: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'cadastro_individual_id' => $ficha['cadastro_individual_id']
                ]));

                break;
            }
            case Origem::CONSUMO_ALIMENTAR: {

                $inconsistencia = Inconsistencia::create(array_merge($dadosInconsistencia, [
                    'consumo_alimentar_id' => $ficha['consumo_alimentar_id']
                ]));

                break;
            }
        }

        self::saveXmlEnvio($cliente, $inconsistencia, $ficha);
    }

    private static function saveXmlEnvio($cliente, $inconsistencia, $ficha)
    {
        $path = Storage::path(self::INCONSISTENCIA_XML_ENVIO_PATH);

        if (file_exists($path) === false) {

            File::makeDirectory($path, 0777, true, true);
        }

        Storage::disk('local')->put(
            self::INCONSISTENCIA_XML_ENVIO_PATH
                . DIRECTORY_SEPARATOR . $cliente
                . DIRECTORY_SEPARATOR . "{$inconsistencia->id}.xml",
            $ficha['xml']['conteudo']
        );
    }

    private static function getOrigemId($nomeFicha)
    {
        switch ($nomeFicha) {

            case 'atendimento_individual': {

                return Origem::ATENDIMENTO_INDIVIDUAL;
            }
            case 'atendimento_domiciliar': {

                return Origem::ATENDIMENTO_DOMICILIAR;
            }
            case 'atendimento_odontologico': {

                return Origem::ATENDIMENTO_ODONTOLOGICO;
            }
            case 'atividade_coletiva': {

                return Origem::ATIVIDADE_COLETIVA;
            }
            case 'avaliacao': {

                return Origem::AVALIACAO;
            }
            case 'procedimento': {

                return Origem::PROCEDIMENTO;
            }
            case 'visita_domiciliar': {

                return Origem::VISITA_DOMICILIAR;
            }
            case 'ficha_vacinacao': {

                return Origem::FICHA_VACINACAO;
            }
            case 'ficha_complementar': {

                return Origem::FICHA_COMPLEMENTAR;
            }
            case 'cadastro_domiciliar': {

                return Origem::CADASTRO_DOMICILIAR;
            }
            case 'cadastro_individual': {

                return Origem::CADASTRO_INDIVIDUAL;
            }
            case 'consumo_alimentar': {

                return Origem::CONSUMO_ALIMENTAR;
            }
        }
    }
}