<?php

namespace App\Services\Bpa;

use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Sigtap\Competencia;
use App\Models\Sigtap\Ocupacao;
use App\Models\Sigtap\Procedimento;
use App\Services\Service;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;

class RelatorioQuantitativoProducaoService extends Service
{
    public static function index()
    {
        $totalizadores = (object) [
            'quantidade' => 0,
            'tipos' => collect()
        ];

        $params = self::getParams();

        $producaoBuilder = DB::table('bpa_procedimento as bpa_procedimento')
            ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'bpa_procedimento.procedimento_id')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'bpa_procedimento.unidade_id')
            ->leftJoin('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'bpa_procedimento.ocupacao_id')
            ->leftJoin('cadastro_usuario as usuario', 'usuario.id', 'bpa_procedimento.usuario_id')
            ->leftJoin('cadastro_cidadao as usuario_cidadao', 'usuario_cidadao.id', 'usuario.cidadao_id')
            ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
            ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
            ->where('bpa_procedimento.competencia_id', $params->competencia_id)
            ->whereNull('unidade.deleted_at')
            ->whereNull('bpa_procedimento.deleted_at')
            ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
            ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
            ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
                ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
                ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
            ))
            ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
                ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
                ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
            ))
            ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
            ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
            ->when($params->procedimento_id, fn ($q, $id) => $q->where('bpa_procedimento.procedimento_id', $id))
            ->when($params->status, fn ($q) => $q
                ->when($params->status === 'exportado', fn ($q) => $q->whereNotNull('bpa_procedimento.exportacao_id'))
                ->when($params->status === 'nao_exportado', fn ($q) => $q->whereNull('bpa_procedimento.exportacao_id'))
            )
            ->selectRaw("
                bpa_procedimento.origem,
                unidade.nome_fantasia as unidade_nome_fantasia,
                procedimento.codigo as procedimento_codigo,
                procedimento.nome as procedimento_nome,
                ocupacao.codigo as ocupacao_codigo,
                ocupacao.nome as ocupacao_nome,
                usuario_cidadao.nome as usuario_nome,
                IF (bpa_procedimento.exportacao_id IS NULL,
                    '" . self::getStatus()->where('value', 'nao_exportado')->first()->text . "',
                    '" . self::getStatus()->where('value', 'exportado')->first()->text . "'
                ) as status,
                SUM(quantidade) as quantidade
            ")
            ->groupByRaw("
                bpa_procedimento.origem,
                unidade.nome_fantasia,
                procedimento.codigo,
                procedimento.nome,
                ocupacao.codigo,
                ocupacao.nome,
                usuario_cidadao.nome,
                status
            ");

        self::setOrderBy($producaoBuilder);

        $producao = $producaoBuilder->get();

        $producao->each(function ($item) use ($totalizadores) {

            $item->procedimento_codigo = MaskUtil::getProcedimentoMasked($item->procedimento_codigo);

            $totalizadores->quantidade += $item->quantidade;
        });

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

    private static function setOrderBy($builder)
    {
        $columns = [
            'origem' => 'bpa_procedimento.origem',
            'unidade_nome_fantasia' => 'unidade.nome_fantasia',
            'procedimento_codigo' => 'procedimento.codigo',
            'procedimento_nome' => 'procedimento.nome',
            'ocupacao_codigo' => 'ocupacao.codigo',
            'ocupacao_nome' => 'ocupacao.nome',
            'usuario_nome' => 'usuario_cidadao.nome',
            'status' => "IF (bpa_procedimento.exportacao_id IS NULL,
                '" . self::getStatus()->where('value', 'nao_exportado')->first()->text . "',
                '" . self::getStatus()->where('value', 'exportado')->first()->text . "'
            )",
            'quantidade' => 'quantidade'
        ];

        if (is_null(request()->sortBy)) {

            $builder->orderByRaw(join(', ', $columns));

            return;
        }

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

        unset($columns[request()->sortBy]);

        $builder->orderByRaw(
            "{$column} {$direction}, " . join(', ', $columns)
        );
    }

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

        $params = self::getParams();

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

                $anosData = self::getAnosData();

                $data->form['anos'] = $anosData['form'];
                $data->model['ano'] = $anosData['model'];

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

                $competenciasData = self::getCompetenciasData($params);

                $data->form['competencias'] = $competenciasData['form'];
                $data->model['competencia_id'] = $competenciasData['model'];

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

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

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

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

                $data->model['idade'] = ['de' => null, 'ate' => null];

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

                $procedimentosData = self::getProcedimentosData($params);

                $data->form['procedimentos'] = $procedimentosData['form'];
                $data->model['procedimento_id'] = $procedimentosData['model'];

                $params->procedimento_id = $data->model['procedimento_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'];
            },
        ];

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

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

            if ($load) {

                if (!$firstLoad && $field === 'idade') {

                    continue;
                }

                $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()
    {
        return (object) request()->only([
            'ano',
            'competencia_id',
            'origem',
            'unidade_id',
            'idade',
            'ocupacao_id',
            'usuario_id',
            'procedimento_id',
            'status',
        ]);
    }

    private static function getAnosData()
    {
        $anos = DB::table('sigtap.competencia as competencia')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('bpa_procedimento as bpa_procedimento')
                ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id')
            )
            ->selectRaw("
                SUBSTRING(competencia.valor, 1, 4) as ano
            ")
            ->orderByRaw("SUBSTRING(competencia.valor, 1, 4) DESC")
            ->distinct()
            ->get();

        $ano = null;

        return ['form' => $anos, 'model' => $ano];
    }

    private static function getCompetenciasData($params)
    {
        $competencias = collect();
        $id = null;

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

            $competencias = DB::table('sigtap.competencia as competencia')
                ->whereRaw("SUBSTRING(competencia.valor, 1, 4) = '{$params->ano}'")
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('bpa_procedimento as bpa_procedimento')
                    ->whereColumn('bpa_procedimento.competencia_id', 'competencia.id')
                )
                ->selectRaw("
                    competencia.id,
                    SUBSTRING(competencia.valor, 5, 7) as mes
                ")
                ->orderByRaw("SUBSTRING(competencia.valor, 5, 7)")
                ->get();
        }

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

    private static function getOrigensData($params)
    {
        $origens = collect();
        $id = null;

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

            $origens = DB::table('bpa_procedimento as bpa_procedimento')
                ->where('bpa_procedimento.competencia_id', $params->competencia_id)
                ->selectRaw("
                    bpa_procedimento.origem
                ")
                ->orderBy('bpa_procedimento.origem')
                ->distinct()
                ->get();
        }

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

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

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

            $unidades = DB::table('cadastro_unidade as unidade')
                ->whereNull('unidade.deleted_at')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('bpa_procedimento as bpa_procedimento')
                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
                    ->whereColumn('bpa_procedimento.unidade_id', 'unidade.id')
                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
                    ))
                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
                    ))
                )
                ->selectRaw("
                    unidade.id,
                    unidade.nome_fantasia
                ")
                ->orderBy('unidade.nome_fantasia')
                ->get();
        }

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

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

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

            $ocupacoes = DB::table('sigtap.ocupacao as ocupacao')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('bpa_procedimento as bpa_procedimento')
                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
                    ->whereColumn('bpa_procedimento.ocupacao_id', 'ocupacao.id')
                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
                    ))
                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
                    ))
                )
                ->selectRaw("
                    ocupacao.id,
                    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->competencia_id)) {

            $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('bpa_procedimento as bpa_procedimento')
                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
                    ->whereColumn('bpa_procedimento.usuario_id', 'usuario.id')
                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
                    ))
                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
                    ))
                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
                )
                ->orderBy('cidadao.nome')
                ->selectRaw("
                    usuario.id,
                    cidadao.nome
                ")
                ->get();
        }

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

    private static function getProcedimentosData($params)
    {
        $procedimentos = collect();
        $id = null;

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

            $procedimentos = DB::table('sigtap.procedimento as procedimento')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('bpa_procedimento as bpa_procedimento')
                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
                    ->whereColumn('bpa_procedimento.procedimento_id', 'procedimento.id')
                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
                    ))
                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
                    ))
                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
                    ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
                )
                ->selectRaw("
                    procedimento.id,
                    CONCAT(procedimento.codigo, ' - ', procedimento.nome) as descricao
                ")
                ->orderByRaw("CONCAT(procedimento.codigo, ' - ', procedimento.nome)")
                ->get();
        }

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

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

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

            $exists = function ($exportado) use ($params) {

                return DB::table('bpa_procedimento as bpa_procedimento')
                    ->leftJoin('cadastro_paciente as paciente', 'paciente.id', 'bpa_procedimento.paciente_id')
                    ->leftJoin('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
                    ->where('bpa_procedimento.competencia_id', $params->competencia_id)
                    ->when($params->origem, fn ($q, $origem) => $q->where('bpa_procedimento.origem', $origem))
                    ->when($params->unidade_id, fn ($q, $id) => $q->where('bpa_procedimento.unidade_id', $id))
                    ->when(isset($params->idade['de']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade >= {$params->idade['de']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) >= {$params->idade['de']}")
                    ))
                    ->when(isset($params->idade['ate']), fn ($q) => $q->where(fn ($q) => $q
                        ->whereRaw("bpa_procedimento.idade <= {$params->idade['ate']}")
                        ->orWhereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, NOW()) <= {$params->idade['ate']}")
                    ))
                    ->when($params->ocupacao_id, fn ($q, $id) => $q->where('bpa_procedimento.ocupacao_id', $id))
                    ->when($params->usuario_id, fn ($q, $id) => $q->where('bpa_procedimento.usuario_id', $id))
                    ->when($params->procedimento_id, fn ($q, $id) => $q->where('bpa_procedimento.procedimento_id', $id))
                    ->when($exportado,
                        fn ($q) => $q->whereNotNull('bpa_procedimento.exportacao_id'),
                        fn ($q) => $q->whereNull('bpa_procedimento.exportacao_id')
                    )
                    ->exists();
            };

            if ($exists(false)) {

                $status->push(self::getStatus()->where('value', 'nao_exportado')->first());
            }

            if ($exists(true)) {

                $status->push(self::getStatus()->where('value', 'exportado')->first());
            }
        }

        return ['form' => $status->sortBy('text')->values(), 'model' => $value];
    }

    private static function getStatus()
    {
        return collect([
            (object) ['value' => 'nao_exportado', 'text' => 'NÃO EXPORTADO'],
            (object) ['value' => 'exportado', 'text' => 'EXPORTADO']
        ]);
    }

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

        $params = self::getParams();

        $competencia = Competencia::find($params->competencia_id);
        $unidade = $params->unidade_id ? Unidade::find($params->unidade_id) : null;
        $ocupacao = $params->ocupacao_id ? Ocupacao::find($params->ocupacao_id) : null;
        $usuario = $params->usuario_id ? Usuario::find($params->usuario_id) : null;
        $procedimento = $params->procedimento_id ? Procedimento::find($params->procedimento_id) : null;
        $status = $params->status ? self::getStatus()->where('value', $params->status)->first() : null;

        return [
            'ano' => Str::substr($competencia->valor, 0, 4),
            'mes' => Str::substr($competencia->valor, 4, 2),
            'origem' => $params->origem ?? 'Todos',
            'unidade' => $unidade->nome_fantasia ?? 'Todas',
            'idadeDe' => $params->idade['de'],
            'idadeAte' => $params->idade['ate'],
            'ocupacao' => $ocupacao
                ? "{$ocupacao->codigo} - {$ocupacao->nome}"
                : 'Todas',
            'usuario' => $usuario->cidadao->nome ?? 'Todos',
            'procedimento' => $procedimento
                ? "{$procedimento->codigo} - {$procedimento->nome}"
                : 'Todos',
            'status' => $status->text ?? 'Todos',
            'colunas' => collect(request()->selectedCols),
            'itens' => $itens,
            'totalizadores' => $resultado['totalizadores'],
        ];
    }
}