<?php

namespace App\Services\Integracao\Esus;

use App\Enums\Integracao\Esus\Origem;
use App\Models\Integracao\Esus\Inconsistencia;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaAtendimentoDomiciliar;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaAtendimentoIndividual;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaAtendimentoOdontologico;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaAtividadeColetiva;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaAvaliacao;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaCadastroDomiciliar;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaCadastroIndividual;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaComplementar;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaConsumoAlimentar;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaProcedimento;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaVacinacao;
use App\Services\Integracao\Esus\GerenciamentoEnvio\Ficha\FichaVisitaDomiciliar;
use App\Services\Integracao\EsusService;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;

class GerenciamentoEnvioService extends Service
{
    public static function index()
    {
        $params = self::getParams();
        
        $inconsistencias = DB::table('integracao_esus_inconsistencia AS inconsistencia')
            ->join('integracao_esus_origem AS origem', 'origem.id', 'inconsistencia.origem_id')
            ->leftJoin('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'inconsistencia.equipe_id')
            ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
            ->join('cadastro_unidade AS unidade', 'unidade.id', 'infraestrutura.unidade_id')
            ->leftJoin('sigtap.ocupacao AS ocupacao', 'ocupacao.id', 'inconsistencia.ocupacao_id')
            ->leftJoin('cadastro_usuario AS usuario', 'usuario.id', 'inconsistencia.usuario_id')
            ->join('cadastro_cidadao AS usuario_cidadao', 'usuario_cidadao.id', 'usuario.cidadao_id')
            ->whereBetween('inconsistencia.data_atendimento', $params->periodo)
            ->when($params->origem_id, fn ($q, $id) => $q->where('inconsistencia.origem_id', $id))
            ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
            ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
            ->when($params->ocupacao_id, fn ($q, $id) => $q->where('inconsistencia.ocupacao_id', $id))
            ->when($params->usuario_id, fn ($q, $id) => $q->where('inconsistencia.usuario_id', $id))
            ->select(
                'inconsistencia.id',
                'inconsistencia.data_atendimento',
                'origem.id AS origem_id',
                'origem.nome AS origem_nome',
                'unidade.nome_fantasia AS unidade_nome_fantasia',
                DB::raw("COALESCE(infraestrutura.nome, unidade.nome_fantasia) AS infraestrutura_nome"),
                DB::raw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) AS ocupacao_descricao"),
                'usuario_cidadao.nome AS usuario_nome',
                'inconsistencia.inconsistencia',
                DB::raw('COUNT(*) OVER (PARTITION BY origem.id) AS total_origem')
            )
            ->get();

            $fichasEnviadas = self::getFichasEnviadas($params);

            return [
                'inconsistencias' => $inconsistencias,
                'fichas_enviadas' => $fichasEnviadas
            ];
    }

    public static function list()
    {
        $data = (object) [
            'additionals' => [],
            'form' => [],
            'model' => [],
        ];

        $params = self::getParams();

        $sets = [
            'periodo' => function () use ($data, $params) {

                $data->model['periodo'] = ['start' => null, 'end' => null];

                $params->periodo = $data->model['periodo'];
            },
            'origem' => function () use ($data, $params) {

                $origensData = self::getOrigensData($params);

                $data->form['origens'] = $origensData['form'];
                $data->model['origem_id'] = $origensData['model'];

                $params->origem_id = $data->model['origem_id'];
            },
            'unidade' => function () use ($data, $params) {

                $unidadesData = self::getUnidadesData($params);

                $data->form['unidades'] = $unidadesData['form'];
                $data->model['unidade_id'] = $unidadesData['model'];

                $params->unidade_id = $data->model['unidade_id'];
            },
            'infraestrutura' => function () use ($data, $params) {

                $infraestruturasData = self::getInfraestruturasData($params);

                $data->form['infraestruturas'] = $infraestruturasData['form'];
                $data->model['infraestrutura_id'] = $infraestruturasData['model'];

                $params->infraestrutura_id = $data->model['infraestrutura_id'];
            },
            'ocupacao' => function () use ($data, $params) {

                $ocupacoesData = self::getOcupacoesData($params);

                $data->form['ocupacoes'] = $ocupacoesData['form'];
                $data->model['ocupacao_id'] = $ocupacoesData['model'];

                $params->ocupacao_id = $data->model['ocupacao_id'];
            },
            'usuario' => function () use ($data, $params) {

                $usuariosData = self::getUsuariosData($params);

                $data->form['usuarios'] = $usuariosData['form'];
                $data->model['usuario_id'] = $usuariosData['model'];

                $params->usuario_id = $data->model['usuario_id'];
            },
        ];

        $load = is_null(request()->load_from);

        if ($load) {

            $data->additionals = [
                'data_atual' => Carbon::today()->format('d/m/Y')
            ];
        }

        foreach ($sets as $field => $set) {

            if ($load) {

                $set();
            }
            else if ($field === request()->load_from) {

                $load = true;
            }
        }

        foreach ($data as $property => $itens) {

            if (empty($itens)) {

                unset($data->{$property});
            }
        }

        return $data;
    }

    private static function getParams()
    {
        $params = (object) request()->only([
            'periodo',
            'origem_id',
            'unidade_id',
            'infraestrutura_id',
            'ocupacao_id',
            'usuario_id',
        ]);

        if (isset($params->periodo)
            && !is_null($params->periodo['start'])
            && !is_null($params->periodo['end'])
        ) {

            $start = Carbon::createFromFormat('d/m/Y', $params->periodo['start'])->startOfDay();
            $end = Carbon::createFromFormat('d/m/Y', $params->periodo['end'])->endOfDay();

            $params->periodo['start'] = $start;
            $params->periodo['end'] = $end;
        }
        else {

            $params->periodo = null;
        }

        return $params;
    }
    private static function getFichasEnviadas($params){
        return DB::query()
            ->fromSub(
                DB::table('atencao_basica_atendimento_domiciliar')
                    ->selectRaw("
                        1 as origem_id,
                        'Atendimento Domiciliar' AS ficha, 
                        data,
                        usuario_id,
                        equipe_id,
                        ocupacao_id
                    ")
                    ->whereNotNull('exportacao_id')
                    ->whereNull('usuario_exportacao_id')
                
                    ->unionAll(         
                        DB::table('atencao_basica_atendimento_individual')
                            ->selectRaw("
                                2 as origem_id,
                                'Atendimento Individual' AS ficha, 
                                data_usuario_responsavel AS data,
                                usuario_id,
                                equipe_id,
                                usuario_ocupacao_id as 'ocupacao_id'
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )


                    ->unionAll(
                        DB::table('atencao_basica_atendimento_odontologico')
                            ->selectRaw("
                                3 as origem_id,
                                'Atendimento Odontologico' AS ficha, 
                                data_atendimento AS data,
                                usuario_id,
                                equipe_id,
                                ocupacao_id
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(
                        DB::table('atencao_basica_atividade_coletiva')
                            ->selectRaw("
                                4 as origem_id,
                                'Atividade Coletiva' AS ficha, 
                                data_usuario_responsavel AS data,
                                usuario_id,
                                equipe_id,
                                usuario_ocupacao_id as 'ocupacao_id'
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(
                        DB::table('atencao_basica_avaliacao')
                            ->selectRaw("
                                5 as origem_id,
                                'Avaliação' AS ficha, 
                                data,
                                usuario_id,
                                equipe_id,
                                ocupacao_id
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(
                        DB::table('atencao_basica_cadastro_domiciliar')
                            ->selectRaw("
                                6 as origem_id,  
                                'Cadastro Domiciliar' AS ficha, 
                                data_usuario_responsavel AS data,
                                usuario_id,
                                equipe_id,
                                usuario_ocupacao_id as 'ocupacao_id'
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(         
                        DB::table('atencao_basica_cadastro_individual')
                            ->selectRaw("
                                7 as origem_id,
                                'Cadastro Individual' AS ficha, 
                                data_usuario_responsavel AS data,
                                usuario_id,
                                equipe_id,
                                usuario_ocupacao_id as 'ocupacao_id'
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(
                        DB::table('atencao_basica_ficha_complementar')
                            ->selectRaw("
                                8 as origem_id,
                                'Ficha Complementar' AS ficha, 
                                data_atendimento AS data,
                                usuario_id,
                                equipe_id,
                                cbo_id as 'ocupacao_id'                        
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(
                        DB::table('atencao_basica_consumo_alimentar')
                            ->selectRaw("
                                9 as origem_id,
                                'Consumo Alimentar' AS ficha, 
                                data_atendimento AS data,
                                usuario_id,
                                equipe_id,
                                cbo_id as 'ocupacao_id'
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(
                        DB::table('atencao_basica_procedimento')
                            ->selectRaw("
                                10 as origem_id,
                                'Procedimento' AS ficha, 
                                data_usuario_responsavel AS data,
                                usuario_id,
                                equipe_id,
                                ocupacao_id
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(
                        DB::table('atencao_basica_ficha_vacinacao')
                            ->selectRaw("
                                11 as origem_id,  
                                'Ficha de vacinação' AS ficha, 
                                data_atendimento AS data,
                                usuario_id,
                                equipe_id,
                                ocupacao_id
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    )

                    ->unionAll(
                        DB::table('atencao_basica_visita_domiciliar')
                            ->selectRaw("
                                12 as origem_id,  
                                'Visita Domiciliar' AS ficha, 
                                data_usuario_responsavel AS data,
                                usuario_id,
                                equipe_id,
                                usuario_ocupacao_id
                            ")
                            ->whereNotNull('exportacao_id')
                            ->whereNull('usuario_exportacao_id')
                    ),
                'totalizadores'
            )
            ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'totalizadores.equipe_id')
            ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'atencao_basica_parametrizacao_equipe.infraestrutura_id')
    

            ->whereBetween('totalizadores.data', $params->periodo)
            ->when($params->origem_id, fn ($q, $id) => $q->where('totalizadores.origem_id', $id))
            ->when($params->usuario_id, fn ($q, $id) => $q->where('totalizadores.usuario_id', $id))
            ->when($params->unidade_id, fn ($q, $id) => $q->where('cadastro_infraestrutura.unidade_id', $id))
            ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe.infraestrutura_id', $id))
            ->when($params->ocupacao_id, fn ($q, $id) => $q->where('totalizadores.ocupacao_id', $id))
            ->select('origem_id', 'ficha', DB::raw('COUNT(*) AS quantidade', 'data','usuario_id', 'ocupacao_id'))
            ->groupBy('ficha')
            ->get();
    }
    private static function getOrigensData($params)
    {
        $origens = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $origens = DB::table('integracao_esus_origem AS origem')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('integracao_esus_inconsistencia AS inconsistencia')
                    ->whereColumn('inconsistencia.origem_id', 'origem.id')
                    ->whereBetween('inconsistencia.data_atendimento', $params->periodo)
                )
                ->select(
                    'origem.id',
                    'origem.nome'
                )
                ->orderBy('origem.nome')
                ->get();
        }

        return ['form' => $origens, 'model' => $id];
    }

    private static function getUnidadesData($params)
    {
        $unidades = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $unidades = DB::table('cadastro_unidade AS unidade')
                ->whereNull('unidade.deleted_at')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('integracao_esus_inconsistencia AS inconsistencia')
                    ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'inconsistencia.equipe_id')
                    ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                    ->whereColumn('infraestrutura.unidade_id', 'unidade.id')
                    ->whereBetween('inconsistencia.data_atendimento', $params->periodo)
                    ->when($params->origem_id, fn ($q, $id) => $q->where('inconsistencia.origem_id', $id))
                )
                ->select('unidade.id', 'unidade.nome_fantasia')
                ->orderBy('unidade.nome_fantasia')
                ->get();
        }

        return ['form' => $unidades, 'model' => $id];
    }

    private static function getInfraestruturasData($params)
    {
        $infraestruturas = collect();
        $id = null;

        if (!is_null($params->unidade_id)) {

            $infraestruturas = DB::table('cadastro_infraestrutura AS infraestrutura')
                ->join('cadastro_unidade AS unidade', 'unidade.id', 'infraestrutura.unidade_id')
                ->whereNull('infraestrutura.deleted_at')
                ->where('infraestrutura.unidade_id', $params->unidade_id)
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('integracao_esus_inconsistencia AS inconsistencia')
                    ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'inconsistencia.equipe_id')
                    ->whereColumn('equipe.infraestrutura_id', 'infraestrutura.id')
                    ->whereBetween('inconsistencia.data_atendimento', $params->periodo)
                    ->when($params->origem_id, fn ($q, $id) => $q->where('inconsistencia.origem_id', $id))
                )
                ->select(
                    'infraestrutura.id',
                    DB::raw("COALESCE(infraestrutura.nome, unidade.nome_fantasia) AS nome")
                )
                ->orderByRaw("COALESCE(infraestrutura.nome, unidade.nome_fantasia)")
                ->get();
        }

        return ['form' => $infraestruturas, 'model' => $id];
    }

    private static function getOcupacoesData($params)
    {
        $ocupacoes = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $ocupacoes = DB::table('sigtap.ocupacao AS ocupacao')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('integracao_esus_inconsistencia AS inconsistencia')
                    ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'inconsistencia.equipe_id')
                    ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                    ->whereColumn('inconsistencia.ocupacao_id', 'ocupacao.id')
                    ->whereBetween('inconsistencia.data_atendimento', $params->periodo)
                    ->when($params->origem_id, fn ($q, $id) => $q->where('inconsistencia.origem_id', $id))
                    ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                    ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                )
                ->select(
                    'ocupacao.id',
                    DB::raw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) AS descricao")
                )
                ->orderByRaw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)")
                ->get();
        }

        return ['form' => $ocupacoes, 'model' => $id];
    }

    private static function getUsuariosData($params)
    {
        $usuarios = collect();
        $id = null;

        if (!is_null($params->periodo)) {

            $usuarios = DB::table('cadastro_usuario AS usuario')
                ->join('cadastro_cidadao AS cidadao', 'cidadao.id', 'usuario.cidadao_id')
                ->whereNull('usuario.deleted_at')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('integracao_esus_inconsistencia AS inconsistencia')
                    ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'inconsistencia.equipe_id')
                    ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'equipe.infraestrutura_id')
                    ->whereColumn('inconsistencia.usuario_id', 'usuario.id')
                    ->whereBetween('inconsistencia.data_atendimento', $params->periodo)
                    ->when($params->origem_id, fn ($q, $id) => $q->where('inconsistencia.origem_id', $id))
                    ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                    ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('equipe.infraestrutura_id', $id))
                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('inconsistencia.ocupacao_id', $id))
                )
                ->select(
                    'usuario.id',
                    'cidadao.nome'
                )
                ->orderBy('cidadao.nome')
                ->get();
        }

        return ['form' => $usuarios, 'model' => $id];
    }

    public static function getInconsistencia($id)
    {
        $inconsistencia = Inconsistencia::findOrFail($id);

        $xmlEnvio = Storage::disk('local')
            ->get(EsusService::INCONSISTENCIA_XML_ENVIO_PATH
                . DIRECTORY_SEPARATOR . app('config')->get('database.default')
                . DIRECTORY_SEPARATOR . "{$inconsistencia->id}.xml");

        switch ($inconsistencia->origem_id) {

            case Origem::ATENDIMENTO_DOMICILIAR: {

                return (new FichaAtendimentoDomiciliar($xmlEnvio, $inconsistencia))();
            }
            case Origem::FICHA_COMPLEMENTAR: {

                return (new FichaComplementar($xmlEnvio, $inconsistencia))();
            }
            case Origem::AVALIACAO: {

                return (new FichaAvaliacao($xmlEnvio, $inconsistencia))();
            }
            case Origem::AVALIACAO: {

                return (new FichaAvaliacao($xmlEnvio, $inconsistencia))();
            }
            case Origem::CONSUMO_ALIMENTAR: {

                return (new FichaConsumoAlimentar($xmlEnvio, $inconsistencia))();
            }
            case Origem::PROCEDIMENTO: {

                return (new FichaProcedimento($xmlEnvio, $inconsistencia))();
            }
            case Origem::VISITA_DOMICILIAR: {

                return (new FichaVisitaDomiciliar($xmlEnvio, $inconsistencia))();
            }
            case Origem::ATENDIMENTO_INDIVIDUAL: {

                return (new FichaAtendimentoIndividual($xmlEnvio, $inconsistencia))();
            }
            case Origem::ATENDIMENTO_ODONTOLOGICO: {

                return (new FichaAtendimentoOdontologico($xmlEnvio, $inconsistencia))();
            }
            case Origem::ATIVIDADE_COLETIVA: {

                return (new FichaAtividadeColetiva($xmlEnvio, $inconsistencia))();
            }
            case Origem::FICHA_VACINACAO: {

                return (new FichaVacinacao($xmlEnvio, $inconsistencia))();
            }
            case Origem::CADASTRO_INDIVIDUAL: {

                return (new FichaCadastroIndividual($xmlEnvio, $inconsistencia))();
            }
            case Origem::CADASTRO_DOMICILIAR: {

                return (new FichaCadastroDomiciliar($xmlEnvio, $inconsistencia))();
            }
        }
    }
}