<?php

namespace App\Services\AtencaoBasica;

use App\Enums\AtencaoBasica\Parametrizacao\Permissao;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\AtencaoBasica\Reterritorializacao\ReterritorializacaoLog;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Sigtap\Ocupacao;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;

class ReterritorializacaoService extends Service
{
    public static function list()
    {
        $params = (object) request()->all();

        switch (request()->listar) {
            case 'unidades': {
                return [
                    'unidades' => self::getUnidades($params),
                    'infraestruturas' => [],
                    'equipes' => [],
                    'ocupacoes' => [],
                ];
            }
            case 'infraestruturas': {
                return [
                    'infraestruturas' => self::getInfraestruturas($params),
                    'equipes' => [],
                    'ocupacoes' => [],
                ];
            }
            case 'equipes': {
                return [
                    'equipes' => self::getEquipes($params),
                    'ocupacoes' => self::getOcupacoes($params),
                ];
            }
            case 'ocupacoes': {
                return [
                    'ocupacoes' => self::getOcupacoes($params),
                ];
            }
        }
    }

    public static function create()
    {
        return [
            'form' => [
                'origem' => [
                    'unidades' => [],
                    'infraestruturas' => [],
                    'equipes' => [],
                    'ocupacoes' => [],
                ],
                'destino' => [
                    'ocupacoes' => [],
                ],
                'historico' => self::getHistoricoReterritorializacao(),
            ],
            'model' => [
                'origem' => [
                    'usuario' => null,
                    'unidade_id' => null,
                    'infraestrutura_id' => null,
                    'equipe_id' => null,
                    'ocupacao_id' => null,
                ],
                'destino' => [
                    'usuario' => null,
                    'ocupacao_id' => null,
                ],
            ],
        ];
    }

    private static function getHistoricoReterritorializacao()
    {
        return DB::table('atencao_basica_reterritorializacao_log AS log')
            ->join('cadastro_lotacao AS lotacao', 'lotacao.id', 'log.created_lotacao_id')
            ->join('cadastro_usuario AS usuario', 'usuario.id', 'lotacao.usuario_id')
            ->join('cadastro_cidadao AS cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->join('cadastro_usuario AS origem_usuario', 'origem_usuario.id', 'log.origem_usuario_id')
            ->join('cadastro_cidadao AS origem_cidadao', 'origem_cidadao.id', 'origem_usuario.cidadao_id')
            ->join('atencao_basica_parametrizacao_equipe AS origem_equipe', 'origem_equipe.id', 'log.origem_equipe_id')
            ->join('atencao_basica_parametrizacao_area AS origem_area', 'origem_area.id', 'origem_equipe.area_id')
            ->join('cadastro_infraestrutura AS origem_infraestrutura', 'origem_infraestrutura.id', 'origem_equipe.infraestrutura_id')
            ->join('cadastro_unidade AS origem_unidade', 'origem_unidade.id', 'origem_infraestrutura.unidade_id')
            ->join('sigtap.ocupacao AS origem_ocupacao', 'origem_ocupacao.id', 'log.origem_ocupacao_id')
            ->join('cadastro_usuario AS destino_usuario', 'destino_usuario.id', 'log.destino_usuario_id')
            ->join('cadastro_cidadao AS destino_cidadao', 'destino_cidadao.id', 'destino_usuario.cidadao_id')
            ->join('atencao_basica_parametrizacao_equipe AS destino_equipe', 'destino_equipe.id', 'log.destino_equipe_id')
            ->join('atencao_basica_parametrizacao_area AS destino_area', 'destino_area.id', 'destino_equipe.area_id')
            ->join('cadastro_infraestrutura AS destino_infraestrutura', 'destino_infraestrutura.id', 'destino_equipe.infraestrutura_id')
            ->join('cadastro_unidade AS destino_unidade', 'destino_unidade.id', 'destino_infraestrutura.unidade_id')
            ->join('sigtap.ocupacao AS destino_ocupacao', 'destino_ocupacao.id', 'log.destino_ocupacao_id')
            ->leftJoin('atencao_basica_parametrizacao_microarea AS origem_microarea', 'origem_microarea.id', 'origem_equipe.microarea_id')
            ->leftJoin('atencao_basica_parametrizacao_microarea AS destino_microarea', 'destino_microarea.id', 'destino_equipe.microarea_id')
            ->select(
                'log.created_at AS data_hora',
                'cidadao.nome AS usuario_alteracao_nome',
                'origem_cidadao.nome AS origem_usuario_nome',
                'origem_unidade.nome_fantasia AS origem_unidade_nome_fantasia',
                DB::raw("COALESCE(origem_infraestrutura.nome, origem_unidade.nome_fantasia) AS origem_infraestrutura_nome"),
                DB::raw("CONCAT(
                    CASE
                        WHEN origem_area.numero_ine IS NOT NULL THEN CONCAT('INE: ', origem_area.numero_ine)
                        ELSE ''
                    END,
                    CASE
                        WHEN origem_area.descricao IS NOT NULL AND origem_area.numero_ine IS NOT NULL THEN ' - Área: '
                        WHEN origem_area.descricao IS NOT NULL THEN 'Área: '
                        ELSE ''
                    END,
                    COALESCE(origem_area.descricao, ''),
                    CASE
                        WHEN origem_microarea.descricao IS NOT NULL
                            AND (origem_area.numero_ine IS NOT NULL OR origem_area.descricao IS NOT NULL) THEN ' - Microárea: '
                        WHEN origem_microarea.descricao IS NOT NULL THEN 'Microárea: '
                        ELSE ''
                    END,
                    COALESCE(origem_microarea.descricao, '')
                ) AS origem_equipe_descricao"),
                DB::raw("CONCAT(origem_ocupacao.codigo, ' - ', origem_ocupacao.nome) AS origem_ocupacao_descricao"),
                'destino_cidadao.nome AS destino_usuario_nome',
                'destino_unidade.nome_fantasia AS destino_unidade_nome_fantasia',
                DB::raw("COALESCE(destino_infraestrutura.nome, destino_unidade.nome_fantasia) AS destino_infraestrutura_nome"),
                DB::raw("CONCAT(
                    CASE
                        WHEN destino_area.numero_ine IS NOT NULL THEN CONCAT('INE: ', destino_area.numero_ine)
                        ELSE ''
                    END,
                    CASE
                        WHEN destino_area.descricao IS NOT NULL AND destino_area.numero_ine IS NOT NULL THEN ' - Área: '
                        WHEN destino_area.descricao IS NOT NULL THEN 'Área: '
                        ELSE ''
                    END,
                    COALESCE(destino_area.descricao, ''),
                    CASE
                        WHEN destino_microarea.descricao IS NOT NULL
                            AND (destino_area.numero_ine IS NOT NULL OR destino_area.descricao IS NOT NULL) THEN ' - Microárea: '
                        WHEN destino_microarea.descricao IS NOT NULL THEN 'Microárea: '
                        ELSE ''
                    END,
                    COALESCE(destino_microarea.descricao, '')
                ) AS destino_equipe_descricao"),
                DB::raw("CONCAT(destino_ocupacao.codigo, ' - ', destino_ocupacao.nome) AS destino_ocupacao_descricao"),
                'log.quantidade_cadastros_individuais',
                'log.quantidade_cadastros_domiciliares',
            )
            ->get();
    }

    public static function autocompleteUsuario()
    {
        return 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('cadastro_lotacao AS lotacao')
                ->join('sigtap.ocupacao AS ocupacao', 'ocupacao.id', 'lotacao.ocupacao_id')
                ->whereColumn('lotacao.usuario_id', 'usuario.id')
                ->whereNull('lotacao.deleted_at')
                ->when(request()->from === 'destino', fn ($q) => $q
                    ->where('lotacao.ativo', true)
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('atencao_basica_parametrizacao_outros_permissao_ocupacao AS permissao_ocupacao')
                        ->whereColumn('permissao_ocupacao.ocupacao', 'ocupacao.codigo')
                        ->where('permissao_ocupacao.permissao_id', Permissao::CADASTRO_DOMICILIAR)
                    )
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('atencao_basica_parametrizacao_outros_permissao_ocupacao AS permissao_ocupacao')
                        ->whereColumn('permissao_ocupacao.ocupacao', 'ocupacao.codigo')
                        ->where('permissao_ocupacao.permissao_id', Permissao::CADASTRO_INDIVIDUAL)
                    )
                )
            )
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('atencao_basica_parametrizacao_equipe_usuario AS equipe_usuario')
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'equipe_usuario.equipe_id')
                ->whereColumn('equipe_usuario.usuario_id', 'usuario.id')
                ->when(request()->from === 'destino', fn ($q) => $q
                    ->where('equipe.id', request()->equipe_id)
                )
            )
            ->select(
                'usuario.id',
                'cidadao.nome'
            );
    }

    private static function getUnidades(object $params)
    {
        return DB::table('cadastro_unidade AS unidade')
            ->whereNull('unidade.deleted_at')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_infraestrutura AS infraestrutura')
                ->whereColumn('infraestrutura.unidade_id', 'unidade.id')
                ->whereNull('infraestrutura.deleted_at')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('cadastro_lotacao AS lotacao')
                    ->join('sigtap.ocupacao AS ocupacao', 'ocupacao.id', 'lotacao.ocupacao_id')
                    ->whereColumn('lotacao.infraestrutura_id', 'infraestrutura.id')
                    ->whereNull('lotacao.deleted_at')
                    ->where('lotacao.usuario_id', $params->usuario_id)
                )
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('atencao_basica_parametrizacao_equipe_usuario AS equipe_usuario')
                    ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'equipe_usuario.equipe_id')
                    ->whereColumn('equipe.infraestrutura_id', 'infraestrutura.id')
                    ->where('equipe_usuario.usuario_id', $params->usuario_id)
                )
            )
            ->select(
                'unidade.id',
                'unidade.nome_fantasia'
            )
            ->orderBy('unidade.nome_fantasia')
            ->get();
    }

    private static function getInfraestruturas(object $params)
    {
        return 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('cadastro_lotacao AS lotacao')
                ->join('sigtap.ocupacao AS ocupacao', 'ocupacao.id', 'lotacao.ocupacao_id')
                ->whereColumn('lotacao.infraestrutura_id', 'infraestrutura.id')
                ->whereNull('lotacao.deleted_at')
                ->where('lotacao.usuario_id', $params->usuario_id)
            )
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('atencao_basica_parametrizacao_equipe_usuario AS equipe_usuario')
                ->join('atencao_basica_parametrizacao_equipe AS equipe', 'equipe.id', 'equipe_usuario.equipe_id')
                ->whereColumn('equipe.infraestrutura_id', 'infraestrutura.id')
                ->where('equipe_usuario.usuario_id', $params->usuario_id)
            )
            ->select(
                'infraestrutura.id',
                DB::raw("COALESCE(infraestrutura.nome, unidade.nome_fantasia) AS nome")
            )
            ->orderByRaw("COALESCE(infraestrutura.nome, unidade.nome_fantasia)")
            ->get();
    }

    private static function getEquipes(object $params)
    {
        return DB::table('atencao_basica_parametrizacao_equipe AS equipe')
            ->join('atencao_basica_parametrizacao_area AS area', 'area.id', 'equipe.area_id')
            ->leftJoin('atencao_basica_parametrizacao_microarea AS microarea', 'microarea.id', 'equipe.microarea_id')
            ->where('equipe.infraestrutura_id', $params->infraestrutura_id)
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('atencao_basica_parametrizacao_equipe_usuario AS equipe_usuario')
                ->whereColumn('equipe_usuario.equipe_id', 'equipe.id')
                ->where('equipe_usuario.usuario_id', $params->usuario_id)
            )
            ->select(
                'equipe.id AS id',
                DB::raw("CONCAT(
                    CASE
                        WHEN area.numero_ine IS NOT NULL THEN CONCAT('INE: ', area.numero_ine)
                        ELSE ''
                    END,
                    CASE
                        WHEN area.descricao IS NOT NULL AND area.numero_ine IS NOT NULL THEN ' - Área: '
                        WHEN area.descricao IS NOT NULL THEN 'Área: '
                        ELSE ''
                    END,
                    COALESCE(area.descricao, ''),
                    CASE
                        WHEN microarea.descricao IS NOT NULL
                            AND (area.numero_ine IS NOT NULL OR area.descricao IS NOT NULL) THEN ' - Microárea: '
                        WHEN microarea.descricao IS NOT NULL THEN 'Microárea: '
                        ELSE ''
                    END,
                    COALESCE(microarea.descricao, '')
                ) AS descricao"),
            )
            ->orderBy('descricao')
            ->get();
    }

    private static function getOcupacoes(object $params)
    {
        return DB::table('sigtap.ocupacao AS ocupacao')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_lotacao AS lotacao')
                ->whereColumn('lotacao.ocupacao_id', 'ocupacao.id')
                ->whereNull('lotacao.deleted_at')
                ->when(request()->from === 'destino', fn ($q) => $q
                    ->where('lotacao.ativo', true)
                )
                ->where('lotacao.usuario_id', $params->usuario_id)
                ->where('lotacao.infraestrutura_id', $params->infraestrutura_id)
            )
            ->when(request()->from === 'destino', fn ($q) => $q
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('atencao_basica_parametrizacao_outros_permissao_ocupacao AS permissao_ocupacao')
                    ->whereColumn('permissao_ocupacao.ocupacao', 'ocupacao.codigo')
                    ->where('permissao_ocupacao.permissao_id', Permissao::CADASTRO_DOMICILIAR)
                )
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('atencao_basica_parametrizacao_outros_permissao_ocupacao AS permissao_ocupacao')
                    ->whereColumn('permissao_ocupacao.ocupacao', 'ocupacao.codigo')
                    ->where('permissao_ocupacao.permissao_id', Permissao::CADASTRO_INDIVIDUAL)
                )
            )
            ->select(
                'ocupacao.id',
                DB::raw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) AS descricao")
            )
            ->orderBy('ocupacao.nome')
            ->get();
    }

    public static function store()
    {
        self::validate();

        return DB::transaction(function () {
            $currentLotacao = self::getCurrentLotacao();
            $currentCentroCusto = self::getCurrentCentroCusto();

            $origem = request()->origem;
            $destino = request()->destino;

            $cadastrosIndividuais = DB::table('atencao_basica_cadastro_individual AS cadastro_individual')
                ->join('cadastro_paciente AS paciente', 'paciente.id', 'cadastro_individual.paciente_id')
                ->join('cadastro_cidadao AS cidadao', 'cidadao.id', 'paciente.cidadao_id')
                ->where('cadastro_individual.usuario_id', $origem['usuario_id'])
                ->where('cadastro_individual.equipe_id', $origem['equipe_id'])
                ->where('cadastro_individual.usuario_ocupacao_id', $origem['ocupacao_id'])
                ->whereNotExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('cadastro_obito AS obito')
                    ->whereColumn('obito.cidadao_id', 'cidadao.id')
                    ->whereNull('obito.deleted_at')
                )
                ->select(
                    'cadastro_individual.id',
                    'cadastro_individual.paciente_id'
                )
                ->get();

            $cadastrosDomiciliares = DB::table('atencao_basica_cadastro_domiciliar AS cadastro_domiciliar')
                ->where('cadastro_domiciliar.usuario_id', $origem['usuario_id'])
                ->where('cadastro_domiciliar.equipe_id', $origem['equipe_id'])
                ->where('cadastro_domiciliar.usuario_ocupacao_id', $origem['ocupacao_id'])
                ->select(
                    'cadastro_domiciliar.id',
                    'cadastro_domiciliar.domicilio_id'
                )
                ->get();

            $cadastrosIndividuaisIds = $cadastrosIndividuais->pluck('id')->toArray();
            $cadastrosDomiciliaresIds = $cadastrosDomiciliares->pluck('id')->toArray();
            $domiciliosIds = $cadastrosDomiciliares->pluck('domicilio_id')->toArray();

            $pacientesIds = DB::table('cadastro_paciente AS paciente')
                ->join('cadastro_cidadao AS cidadao', 'cidadao.id', 'paciente.cidadao_id')
                ->whereIn('cidadao.domicilio_id', $domiciliosIds)
                ->pluck('paciente.id')
                ->concat($cadastrosIndividuais->pluck('paciente_id'))
                ->unique()
                ->values()
                ->toArray();

            DB::table('atencao_basica_cadastro_individual')
                ->whereIn('id', $cadastrosIndividuaisIds)
                ->update([
                    'usuario_id' => $destino['usuario_id'],
                    'equipe_id' => $destino['equipe_id'],
                    'usuario_ocupacao_id' => $destino['ocupacao_id'],
                    'exportacao_id' => null,
                    'usuario_exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'updated_at' => Carbon::now()->format('Y-m-d H:i:s'),
                    'updated_lotacao_id' => $currentLotacao->id,
                    'updated_centro_custo_id' => $currentCentroCusto->id,
                ]);

            DB::table('atencao_basica_cadastro_domiciliar')
                ->whereIn('id', $cadastrosDomiciliaresIds)
                ->update([
                    'usuario_id' => $destino['usuario_id'],
                    'equipe_id' => $destino['equipe_id'],
                    'usuario_ocupacao_id' => $destino['ocupacao_id'],
                    'exportacao_id' => null,
                    'usuario_exportacao_id' => null,
                    'data_hora_exportacao' => null,
                    'updated_at' => Carbon::now()->format('Y-m-d H:i:s'),
                    'updated_lotacao_id' => $currentLotacao->id,
                    'updated_centro_custo_id' => $currentCentroCusto->id,
                ]);

            DB::table('cadastro_paciente_responsavel')
                ->whereIn('paciente_id', $pacientesIds)
                ->update([
                    'responsavel_usuario_id' => $destino['usuario_id'],
                    'responsavel_equipe_id' => $destino['equipe_id'],
                    'responsavel_ocupacao_id' => $destino['ocupacao_id'],
                    'updated_at' => Carbon::now()->format('Y-m-d H:i:s'),
                    'updated_lotacao_id' => $currentLotacao->id,
                    'updated_centro_custo_id' => $currentCentroCusto->id,
                ]);

            $quantidadeCadastrosIndividuais = count($cadastrosIndividuaisIds);
            $quantidadeCadastrosDomiciliares = count($cadastrosDomiciliaresIds);

            if ($quantidadeCadastrosIndividuais > 0 || $quantidadeCadastrosDomiciliares > 0) {
                ReterritorializacaoLog::create([
                    'origem_usuario_id' => $origem['usuario_id'],
                    'origem_equipe_id' => $origem['equipe_id'],
                    'origem_ocupacao_id' => $origem['ocupacao_id'],
                    'destino_usuario_id' => $destino['usuario_id'],
                    'destino_equipe_id' => $destino['equipe_id'],
                    'destino_ocupacao_id' => $destino['ocupacao_id'],
                    'quantidade_cadastros_individuais' => $quantidadeCadastrosIndividuais,
                    'quantidade_cadastros_domiciliares' => $quantidadeCadastrosDomiciliares,
                    'dados' => json_encode([
                        'cadastros_individuais_ids' => $cadastrosIndividuaisIds,
                        'cadastros_domiciliares_ids' => $cadastrosDomiciliaresIds,
                    ]),
                ]);
            }

            return [
                'quantidade_cadastros_individuais' => $quantidadeCadastrosIndividuais,
                'quantidade_cadastros_domiciliares' => $quantidadeCadastrosDomiciliares,
            ];
        });
    }

    private static function validate()
    {
        request()->validate([
            'origem.usuario_id' => [
                'required',
                'integer',
                Rule::exists(Usuario::class, 'id')
            ],
            'origem.equipe_id' => [
                'required',
                'integer',
                Rule::exists(Equipe::class, 'id')
            ],
            'origem.ocupacao_id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id')
            ],
            'destino.usuario_id' => [
                'required',
                'integer',
                Rule::exists(Usuario::class, 'id')
            ],
            'destino.equipe_id' => [
                'required',
                'integer',
                Rule::exists(Equipe::class, 'id')
            ],
            'destino.ocupacao_id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id')
            ],
        ]);
    }
}