<?php

namespace App\Services\Cadastro;

use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Sexo;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Sigtap\Ocupacao;
use App\Services\Service;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class RelatorioUsuarioService extends Service
{
    public static function index()
    {
        $totalizadores = (object) [
            'usuario' => 0,
        ];

        $params = self::getParams();

        $usuariosBuilder = DB::table('cadastro_usuario AS usuario')
            ->join('cadastro_cidadao AS cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->leftJoin('cadastro_sexo AS sexo', 'sexo.id', 'cidadao.sexo_id')
            ->join('cadastro_lotacao AS lotacao', 'lotacao.usuario_id', 'usuario.id')
            ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
            ->join('cadastro_unidade AS unidade', 'unidade.id', 'infraestrutura.unidade_id')
            ->join('sigtap.ocupacao', 'ocupacao.id', 'lotacao.ocupacao_id')
            ->whereNull('usuario.deleted_at')
            ->whereNull('lotacao.deleted_at')
            ->when(is_bool($params->lotacao_principal), fn ($q) => $q->where('lotacao.principal', $params->lotacao_principal))
            ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
            ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('lotacao.infraestrutura_id', $id))
            ->when($params->ocupacao_id, fn ($q, $id) => $q->where('lotacao.ocupacao_id', $id))
            ->when($params->status, fn ($q, $status) => $q
                ->when($status === 'bloqueado', fn ($q) => $q->where('usuario.bloqueado', true))
                ->when($status === 'desbloqueado', fn ($q) => $q->where('usuario.bloqueado', false))
            )
            ->when($params->sexo_id, fn ($q, $id) => $q->where('sexo.id', $id))
            ->when($params->usuario_id, fn ($q, $id) => $q->where('usuario.id', $id))
            ->select(
                'usuario.id AS usuario_id',
                'cidadao.nome AS usuario_nome',
                'sexo.descricao AS sexo_descricao',
                'cidadao.data_nascimento AS usuario_data_nascimento',
                'cidadao.cpf AS usuario_cpf',
                'cidadao.cns AS usuario_cns',
                DB::raw("IF(usuario.bloqueado = 1, 'BLOQUEADO', 'DESBLOQUEADO') AS status"),
                '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"),
                DB::raw("IF(lotacao.principal = 1, 'SIM', 'NÃO') AS lotacao_principal")
            );

        self::setOrderBy($usuariosBuilder);

        $usuarios = $usuariosBuilder->get();

        $totalizadores->usuario = $usuarios->pluck('usuario_id')->unique()->count();

        $usuarios->each(function ($item) {

            $item->usuario_cpf = MaskUtil::getCpfMasked($item->usuario_cpf);
            $item->usuario_cns = MaskUtil::getCnsMasked($item->usuario_cns);

            unset($item->usuario_id);
        });

        return compact('usuarios', 'totalizadores');
    }

    private static function setOrderBy($builder)
    {
        if (is_null(request()->sortBy)) {

            $builder->orderBy('lotacao.id');

            return;
        }

        $columns = [
            'usuario_nome' => 'cidadao.nome',
            'sexo_descricao' => 'sexo.descricao',
            'usuario_data_nascimento' => 'cidadao.data_nascimento',
            'usuario_cpf' => 'cidadao.cpf',
            'usuario_cns' => 'cidadao.cns',
            'status' => 'status',
            'unidade_nome_fantasia' => 'unidade.nome_fantasia',
            'infraestrutura_nome' => 'infraestrutura_nome',
            'ocupacao_descricao' => 'ocupacao_descricao',
            'lotacao_principal' => 'lotacao_principal'
        ];

        $column = $columns[request()->sortBy];
        $direction = DataUtil::getBooleanValueFromStringBoolean(request()->sortDesc) ? 'DESC' : 'ASC';

        $builder->orderByRaw(
            "{$column} {$direction}, lotacao.id"
        );
    }

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

        $params = self::getParams();

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

                $lotacaoPrincipalData = self::getLotacaoPrincipalData($params);

                $data->form['lotacao_principal'] = $lotacaoPrincipalData['form'];
                $data->model['lotacao_principal'] = $lotacaoPrincipalData['model'];

                $params->lotacao_principal = $data->model['lotacao_principal'];
            },
            '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'];
            },
            'status' => function () use ($data, $params) {

                $statusData = self::getStatusData($params);

                $data->form['status'] = $statusData['form'];
                $data->model['status'] = $statusData['model'];

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

                $sexosData = self::getSexosData($params);

                $data->form['sexos'] = $sexosData['form'];
                $data->model['sexo_id'] = $sexosData['model'];

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

                $data->model['usuario'] = null;

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

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

        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([
            'lotacao_principal',
            'unidade_id',
            'infraestrutura_id',
            'ocupacao_id',
            'status',
            'sexo_id',
            'usuario_id',
        ]);

        if (isset($params->lotacao_principal) && DataUtil::isStringBoolean($params->lotacao_principal)) {

            $params->lotacao_principal = DataUtil::getBooleanValueFromStringBoolean($params->lotacao_principal);
        }

        return $params;
    }

    private static function getLotacaoPrincipalData()
    {
        $lotacaoPrincipal = collect();

        $hasLotacaoNaoPrincipal = DB::table('cadastro_lotacao AS lotacao')
            ->whereNull('lotacao.deleted_at')
            ->where('lotacao.principal', false)
            ->exists();

        $hasLotacaoPrincipal = DB::table('cadastro_lotacao AS lotacao')
            ->whereNull('lotacao.deleted_at')
            ->where('lotacao.principal', true)
            ->exists();

        if ($hasLotacaoNaoPrincipal) {

            $lotacaoPrincipal->push((object) ['value' => false, 'text' => 'NÃO']);
        }

        if ($hasLotacaoPrincipal) {

            $lotacaoPrincipal->push((object) ['value' => true, 'text' => 'SIM']);
        }

        return ['form' => $lotacaoPrincipal, 'model' => null];
    }

    private static function getUnidadesData($params)
    {
        $unidades = 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')
                    ->whereColumn('lotacao.infraestrutura_id', 'infraestrutura.id')
                    ->whereNull('lotacao.deleted_at')
                    ->when(is_bool($params->lotacao_principal), fn ($q) => $q->where('lotacao.principal', $params->lotacao_principal))
                )
            )
            ->select(
                'unidade.id',
                'unidade.nome_fantasia'
            )
            ->orderBy('unidade.nome_fantasia')
            ->get();

        $id = null;

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

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

        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('cadastro_lotacao AS lotacao')
                    ->whereColumn('lotacao.infraestrutura_id', 'infraestrutura.id')
                    ->whereNull('lotacao.deleted_at')
                    ->when(is_bool($params->lotacao_principal), fn ($q) => $q->where('lotacao.principal', $params->lotacao_principal))
                )
                ->select(
                    'infraestrutura.id',
                    DB::raw('COALESCE(infraestrutura.nome, unidade.nome_fantasia) AS nome')
                )
                ->orderByRaw('COALESCE(infraestrutura.nome, unidade.nome_fantasia)')
                ->get();
        }

        $id = null;

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

    private static function getOcupacoesData($params)
    {
        $ocupacoes = DB::table('sigtap.ocupacao AS ocupacao')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_lotacao AS lotacao')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                ->whereColumn('lotacao.ocupacao_id', 'ocupacao.id')
                ->whereNull('lotacao.deleted_at')
                ->when(is_bool($params->lotacao_principal), fn ($q) => $q->where('lotacao.principal', $params->lotacao_principal))
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('lotacao.infraestrutura_id', $id))
            )
            ->selectRaw("
                ocupacao.id,
                CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) as descricao
            ")
            ->orderByRaw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)")
            ->get();

        $id = null;

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

    private static function getStatusData($params)
    {
        $status = collect();

        $hasBloqueado = DB::table('cadastro_usuario AS usuario')
            ->whereNull('usuario.deleted_at')
            ->where('usuario.bloqueado', true)
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_lotacao AS lotacao')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                ->whereColumn('lotacao.usuario_id', 'usuario.id')
                ->whereNull('lotacao.deleted_at')
                ->when(is_bool($params->lotacao_principal), fn ($q) => $q->where('lotacao.principal', $params->lotacao_principal))
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('lotacao.infraestrutura_id', $id))
                ->when($params->ocupacao_id, fn ($q, $id) => $q->where('lotacao.ocupacao_id', $id))
            )
            ->exists();

        $hasDesbloqueado = DB::table('cadastro_usuario AS usuario')
            ->whereNull('usuario.deleted_at')
            ->where('usuario.bloqueado', false)
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_lotacao AS lotacao')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                ->whereColumn('lotacao.usuario_id', 'usuario.id')
                ->whereNull('lotacao.deleted_at')
                ->when(is_bool($params->lotacao_principal), fn ($q) => $q->where('lotacao.principal', $params->lotacao_principal))
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('lotacao.infraestrutura_id', $id))
                ->when($params->ocupacao_id, fn ($q, $id) => $q->where('lotacao.ocupacao_id', $id))
            )
            ->exists();

        if ($hasBloqueado) {

            $status->push((object) ['value' => 'bloqueado', 'text' => 'BLOQUEADO']);
        }

        if ($hasDesbloqueado) {

            $status->push((object) ['value' => 'desbloqueado', 'text' => 'DESBLOQUEADO']);
        }

        return ['form' => $status, 'model' => null];
    }

    private static function getSexosData($params)
    {
        $sexos = DB::table('cadastro_sexo AS sexo')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_cidadao AS cidadao')
                ->join('cadastro_usuario AS usuario', 'usuario.cidadao_id', 'cidadao.id')
                ->join('cadastro_lotacao AS lotacao', 'lotacao.usuario_id', 'usuario.id')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                ->whereColumn('cidadao.sexo_id', 'sexo.id')
                ->whereNull('lotacao.deleted_at')
                ->when(is_bool($params->lotacao_principal), fn ($q) => $q->where('lotacao.principal', $params->lotacao_principal))
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('lotacao.infraestrutura_id', $id))
                ->when($params->ocupacao_id, fn ($q, $id) => $q->where('lotacao.ocupacao_id', $id))
                ->when($params->status, fn ($q, $status) => $q
                    ->when($status === 'bloqueado', fn ($q) => $q->where('usuario.bloqueado', true))
                    ->when($status === 'desbloqueado', fn ($q) => $q->where('usuario.bloqueado', false))
                )
            )
            ->select(
                'sexo.id',
                'sexo.descricao'
            )
            ->orderBy('sexo.descricao')
            ->get();

        $id = null;

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

    public static function autocompleteUsuario()
    {
        $params = self::getParams();

        return DB::table('cadastro_usuario AS usuario')
            ->join('cadastro_cidadao AS cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->leftJoin('cadastro_sexo AS sexo', 'sexo.id', 'cidadao.sexo_id')
            ->when($params->status, fn ($q, $status) => $q
                ->when($status === 'bloqueado', fn ($q) => $q->where('usuario.bloqueado', true))
                ->when($status === 'desbloqueado', fn ($q) => $q->where('usuario.bloqueado', false))
            )
            ->when($params->sexo_id, fn ($q, $id) => $q->where('sexo.id', $id))
            ->whereNull('usuario.deleted_at')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_lotacao AS lotacao')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                ->whereColumn('lotacao.usuario_id', 'usuario.id')
                ->whereNull('lotacao.deleted_at')
                ->when(is_bool($params->lotacao_principal), fn ($q) => $q->where('lotacao.principal', $params->lotacao_principal))
                ->when($params->unidade_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->infraestrutura_id, fn ($q, $id) => $q->where('lotacao.infraestrutura_id', $id))
                ->when($params->ocupacao_id, fn ($q, $id) => $q->where('lotacao.ocupacao_id', $id))
            )
            ->select(
                'usuario.id',
                'cidadao.nome'
            );
    }

    public static function getPrintExportData()
    {
        $resultado = self::index();
        $itens = $resultado['usuarios'];

        $itens->each(function ($item) {

            if ($item->usuario_data_nascimento) {

                $item->usuario_data_nascimento = Carbon::create($item->usuario_data_nascimento)->format('d/m/Y');
            }
        });

        $params = self::getParams();

        $lotacaoPrincipal = is_bool($params->lotacao_principal) ? ($params->lotacao_principal ? 'SIM' : 'NÃO') : null;
        $unidade = $params->unidade_id ? Unidade::find($params->unidade_id) : null;
        $infraestrutura = $params->infraestrutura_id ? Infraestrutura::find($params->infraestrutura_id) : null;
        $ocupacao = $params->ocupacao_id ? Ocupacao::find($params->ocupacao_id) : null;
        $status = $params->status ? ($params->status === 'bloqueado' ? 'BLOQUEADO' : 'DESBLOQUEADO') : null;
        $sexo = $params->sexo_id ? Sexo::find($params->sexo_id) : null;
        $usuario = $params->usuario_id ? Usuario::find($params->usuario_id) : null;

        return [
            'lotacaoPrincipal' => $lotacaoPrincipal ?? 'Todas',
            'unidade' => $unidade->nome_fantasia ?? 'Todas',
            'infraestrutura' => $infraestrutura->nome ?? 'Todos',
            'ocupacao' => $ocupacao
                ? "{$ocupacao->codigo} - {$ocupacao->nome}"
                : 'Todas',
            'status' => $status ?? 'Todos',
            'sexo' => $sexo->descricao ?? 'Todos',
            'usuario' => $usuario->cidadao->nome ?? null,
            'colunas' => collect(request()->selectedCols),
            'itens' => $itens,
            'totalizadores' => $resultado['totalizadores'],
        ];
    }
}