<?php

namespace App\Services\Apac;

use App\Services\Service;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;
use Illuminate\Support\Facades\DB;

class RelatorioInconsistenciaService extends Service
{
    public static function index()
    {
        $params = self::getParams();

        $inconsistencias = collect();

        if ($params->tipo_inconsistencia === 'procedimento-principal') {
            $inconsistencias = DB::table('apac_solicitacao_autorizacao')
                ->select([
                    'apac_solicitacao_autorizacao.id AS solicitacao_autorizacao_id',
                    'apac_solicitacao_autorizacao.data_processamento',
                    DB::raw("LPAD(cadastro_paciente.prontuario, 7, 0) as prontuario"),
                    'paciente_cidadao.nome as paciente_nome',
                    'cadastro_unidade.nome_fantasia as unidade_executante_nome_fantasia',
                    'usuario_cidadao.nome as usuario_executante_nome',
                    'ocupacao.codigo as ocupacao_codigo',
                    'procedimento.codigo as procedimento_codigo',
                    'procedimento.nome as procedimento_nome',
                    DB::raw("CONCAT(cid.codigo, ' - ', cid.nome) as cid_descricao")
                ])
                ->join('cadastro_paciente', 'cadastro_paciente.id', 'apac_solicitacao_autorizacao.paciente_id')
                ->join('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'cadastro_paciente.cidadao_id')
                ->join('cadastro_unidade', 'cadastro_unidade.id', 'apac_solicitacao_autorizacao.unidade_executante_id')
                ->join('cadastro_usuario', 'cadastro_usuario.id', 'apac_solicitacao_autorizacao.usuario_executante_id')
                ->join('cadastro_cidadao as usuario_cidadao', 'usuario_cidadao.id', 'cadastro_usuario.cidadao_id')
                ->join('sigtap.ocupacao', 'ocupacao.id', 'apac_solicitacao_autorizacao.procedimento_principal_ocupacao_id')
                ->join('sigtap.procedimento', 'procedimento.id', 'apac_solicitacao_autorizacao.procedimento_principal_id')
                ->leftJoin('sigtap.cid', 'cid.id', 'apac_solicitacao_autorizacao.procedimento_principal_cid_principal_id')
                ->whereExists(fn($q) => $q->select(DB::raw(1))
                    ->from('apac_solicitacao_autorizacao_inconsistencia')
                    ->whereColumn('apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id', 'apac_solicitacao_autorizacao.id')
                )
                ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                ->when($params->unidade_executante_id, fn ($q, $id) => $q
                    ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                ->when($params->usuario_executante_id, fn ($q, $id) => $q
                    ->where('apac_solicitacao_autorizacao.usuario_executante_id', $id))
                ->when($params->ocupacao_id, fn ($q, $id) => $q
                    ->where('apac_solicitacao_autorizacao.procedimento_principal_ocupacao_id', $id))
                ->when($params->procedimento_id, fn ($q, $id) => $q
                    ->where('apac_solicitacao_autorizacao.procedimento_principal_id', $id))
                ->when(count($params->cids) === 0,
                    fn ($q) => $q->whereNull('apac_solicitacao_autorizacao.procedimento_principal_cid_principal_id'),
                    fn ($q) => $q->whereIn('apac_solicitacao_autorizacao.procedimento_principal_cid_principal_id', $params->cids)
                );

            self::setOrderBy($inconsistencias);

            $inconsistencias = $inconsistencias->get()
                ->map(function ($query) {
                    $inconsistencia = [
                        'solicitacao_autorizacao_id' => $query->solicitacao_autorizacao_id,
                        'data_processamento' => $query->data_processamento,
                        'prontuario' => $query->prontuario,
                        'paciente_nome' => $query->paciente_nome,
                        'unidade_executante_nome_fantasia' => $query->unidade_executante_nome_fantasia,
                        'usuario_executante_nome' => $query->usuario_executante_nome,
                        'ocupacao_codigo' => $query->ocupacao_codigo,
                        'procedimento_descricao' => MaskUtil::getProcedimentoMasked($query->procedimento_codigo)
                            . " - {$query->procedimento_nome}",
                        'cid_descricao' => $query->cid_descricao,
                        'inconsistencias' => DB::table('apac_solicitacao_autorizacao_inconsistencia')
                            ->select(['apac_inconsistencia.descricao AS inconsistencia_descricao'])
                            ->join('apac_inconsistencia', 'apac_inconsistencia.id', 'apac_solicitacao_autorizacao_inconsistencia.inconsistencia_id')
                            ->where('apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id', $query->solicitacao_autorizacao_id)
                            ->get()
                    ];

                    return $inconsistencia;
                });
        }
        else if ($params->tipo_inconsistencia === 'procedimento-secundario') {
            $inconsistencias = DB::table('apac_solicitacao_autorizacao_procedimento_secundario')
                ->select([
                    'apac_solicitacao_autorizacao.id AS solicitacao_autorizacao_id',
                    'apac_solicitacao_autorizacao_procedimento_secundario.id AS procedimento_secundario_id',
                    'apac_solicitacao_autorizacao.data_processamento',
                    DB::raw("LPAD(cadastro_paciente.prontuario, 7, 0) as prontuario"),
                    'paciente_cidadao.nome as paciente_nome',
                    'cadastro_unidade.nome_fantasia as unidade_executante_nome_fantasia',
                    'usuario_cidadao.nome as usuario_executante_nome',
                    'ocupacao.codigo as ocupacao_codigo',
                    'procedimento.codigo as procedimento_codigo',
                    'procedimento.nome as procedimento_nome',
                    DB::raw("CONCAT(cid.codigo, ' - ', cid.nome) as cid_descricao")
                ])
                ->join('apac_solicitacao_autorizacao', 'apac_solicitacao_autorizacao.id', 'apac_solicitacao_autorizacao_procedimento_secundario.solicitacao_autorizacao_id')
                ->join('cadastro_paciente', 'cadastro_paciente.id', 'apac_solicitacao_autorizacao.paciente_id')
                ->join('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'cadastro_paciente.cidadao_id')
                ->join('cadastro_unidade', 'cadastro_unidade.id', 'apac_solicitacao_autorizacao.unidade_executante_id')
                ->join('cadastro_usuario', 'cadastro_usuario.id', 'apac_solicitacao_autorizacao.usuario_executante_id')
                ->join('cadastro_cidadao as usuario_cidadao', 'usuario_cidadao.id', 'cadastro_usuario.cidadao_id')
                ->join('sigtap.ocupacao', 'ocupacao.id', 'apac_solicitacao_autorizacao_procedimento_secundario.ocupacao_id')
                ->join('sigtap.procedimento', 'procedimento.id', 'apac_solicitacao_autorizacao_procedimento_secundario.procedimento_id')
                ->leftJoin('sigtap.cid', 'cid.id', 'apac_solicitacao_autorizacao_procedimento_secundario.cid_principal_id')
                ->whereExists(fn($q) => $q->select(DB::raw(1))
                    ->from('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                    ->whereColumn('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id', 'apac_solicitacao_autorizacao_procedimento_secundario.id')
                )
                ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                ->when($params->unidade_executante_id, fn ($q, $id) => $q
                    ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                ->when($params->usuario_executante_id, fn ($q, $id) => $q
                    ->where('apac_solicitacao_autorizacao.usuario_executante_id', $id))
                ->when($params->ocupacao_id, fn ($q, $id) => $q
                    ->where('apac_solicitacao_autorizacao_procedimento_secundario.ocupacao_id', $id))
                ->when($params->procedimento_id, fn ($q, $id) => $q
                    ->where('apac_solicitacao_autorizacao_procedimento_secundario.procedimento_id', $id))
                ->when(count($params->cids) === 0,
                    fn ($q) => $q->whereNull('apac_solicitacao_autorizacao_procedimento_secundario.cid_principal_id'),
                    fn ($q) => $q->whereIn('apac_solicitacao_autorizacao_procedimento_secundario.cid_principal_id', $params->cids)
                );

            self::setOrderBy($inconsistencias);

            $inconsistencias = $inconsistencias->get()
                ->map(function ($query) {
                    $inconsistencia = [
                        'solicitacao_autorizacao_id' => $query->solicitacao_autorizacao_id,
                        'data_processamento' => $query->data_processamento,
                        'prontuario' => $query->prontuario,
                        'paciente_nome' => $query->paciente_nome,
                        'unidade_executante_nome_fantasia' => $query->unidade_executante_nome_fantasia,
                        'usuario_executante_nome' => $query->usuario_executante_nome,
                        'ocupacao_codigo' => $query->ocupacao_codigo,
                        'procedimento_descricao' => MaskUtil::getProcedimentoMasked($query->procedimento_codigo)
                            . " - {$query->procedimento_nome}",
                        'cid_descricao' => $query->cid_descricao,
                        'inconsistencias' => DB::table('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                            ->select(['apac_inconsistencia.descricao AS inconsistencia_descricao'])
                            ->join('apac_inconsistencia', 'apac_inconsistencia.id', 'apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.inconsistencia_id')
                            ->where('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id', $query->procedimento_secundario_id)
                            ->get(),
                    ];

                    return $inconsistencia;
                });
        }

        return ['itens' => $inconsistencias];
    }

    public static function create()
    {
        return [
            'form' => [
                'competencias' => self::getCompetencias(),
                'tipos_inconsistencia' => [],
                'unidades_executantes' => [],
                'ocupacoes' => [],
                'cids' => [],
            ],
            'model' => [
                'competencia_id' => null,
                'tipo_inconsistencia' => null,
                'unidade_executante_id' => null,
                'usuario_executante' => null,
                'ocupacao_id' => null,
                'procedimento' => null,
                'cids' => [],
            ],
        ];
    }

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

        switch (request()->listar) {
            case 'tipos-inconsistencia': {
                return [
                    'tipos_inconsistencia' => self::getTiposInconsistencia($params),
                    'unidades_executantes' => [],
                    'ocupacoes' => [],
                    'cids' => [],
                ];
            }
            case 'unidades-executantes': {
                return [
                    'unidades_executantes' => self::getUnidadesExecutantes($params),
                    'ocupacoes' => self::getOcupacoes($params),
                    'cids' => self::getCids($params),
                ];
            }
            case 'ocupacoes': {
                return [
                    'ocupacoes' => self::getOcupacoes($params),
                    'cids' => self::getCids($params),
                ];
            }
            case 'cids': {
                return [
                    'cids' => self::getCids($params),
                ];
            }
        }
    }

    private static function getParams()
    {
        return (object) [
            'competencia_id' => request()->get('competencia_id'),
            'tipo_inconsistencia' => request()->get('tipo_inconsistencia'),
            'unidade_executante_id' => request()->get('unidade_executante_id'),
            'usuario_executante_id' => request()->get('usuario_executante_id'),
            'ocupacao_id' => request()->get('ocupacao_id'),
            'procedimento_id' => request()->get('procedimento_id'),
            'cids' => request()->get('cids', []),
        ];
    }

    private static function getCompetencias()
    {
        return DB::table('sigtap.competencia')
            ->select([
                'competencia.id',
                'competencia.valor',
            ])
            ->whereExists(fn($q) => $q->select(DB::raw(1))
                ->from('apac_solicitacao_autorizacao_inconsistencia')
                ->join(
                    'apac_solicitacao_autorizacao',
                    'apac_solicitacao_autorizacao.id',
                    'apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id'
                )
                ->whereColumn('apac_solicitacao_autorizacao.competencia_id', 'competencia.id')
            )
            ->orWhereExists(fn($q) => $q->select(DB::raw(1))
                ->from('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                ->join(
                    'apac_solicitacao_autorizacao_procedimento_secundario',
                    'apac_solicitacao_autorizacao_procedimento_secundario.id',
                    'apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id'
                )
                ->join(
                    'apac_solicitacao_autorizacao',
                    'apac_solicitacao_autorizacao.id',
                    'apac_solicitacao_autorizacao_procedimento_secundario.solicitacao_autorizacao_id'
                )
                ->whereColumn('apac_solicitacao_autorizacao.competencia_id', 'competencia.id')
            )
            ->orderByDesc('competencia.valor')
            ->get();
    }

    private static function getTiposInconsistencia($params)
    {
        $tipos = [];

        $procedimentoPrincipal = DB::table('apac_solicitacao_autorizacao')
            ->whereExists(fn($q) => $q->select(DB::raw(1))
                ->from('apac_solicitacao_autorizacao_inconsistencia')
                ->whereColumn('apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id', 'apac_solicitacao_autorizacao.id')
            )
            ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
            ->exists();

        $procedimentoSecundario = DB::table('apac_solicitacao_autorizacao')
            ->whereExists(fn($q) => $q->select(DB::raw(1))
                ->from('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                ->join(
                    'apac_solicitacao_autorizacao_procedimento_secundario',
                    'apac_solicitacao_autorizacao_procedimento_secundario.id',
                    'apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id'
                )
                ->whereColumn('apac_solicitacao_autorizacao_procedimento_secundario.solicitacao_autorizacao_id', 'apac_solicitacao_autorizacao.id')
            )
            ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
            ->exists();

        if ($procedimentoPrincipal) {
            $tipos[] = [
                'valor' => 'procedimento-principal',
                'descricao' => 'Procedimento principal',
            ];
        }

        if ($procedimentoSecundario) {
            $tipos[] = [
                'valor' => 'procedimento-secundario',
                'descricao' => 'Procedimento secundário',
            ];
        }

        return $tipos;
    }

    private static function getUnidadesExecutantes($params)
    {
        return DB::table('cadastro_unidade')
            ->select([
                'cadastro_unidade.id',
                'cadastro_unidade.nome_fantasia',
            ])
            ->when($params->tipo_inconsistencia, function ($query, $tipoInconsistencia) use ($params) {
                if ($tipoInconsistencia === 'procedimento-principal') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao.unidade_executante_id', 'cadastro_unidade.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                    );
                }
                else if ($tipoInconsistencia === 'procedimento-secundario') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao_procedimento_secundario',
                            'apac_solicitacao_autorizacao_procedimento_secundario.id',
                            'apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id'
                        )
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_procedimento_secundario.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao.unidade_executante_id', 'cadastro_unidade.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                    );
                }
            })
            ->orderBy('cadastro_unidade.nome_fantasia')
            ->get();
    }

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

        return DB::table('cadastro_usuario')
            ->join('cadastro_cidadao', 'cadastro_cidadao.id', 'cadastro_usuario.cidadao_id')
            ->select([
                'cadastro_usuario.id',
                'cadastro_cidadao.nome',
            ])
            ->when($params->tipo_inconsistencia, function ($query, $tipoInconsistencia) use ($params) {
                if ($tipoInconsistencia === 'procedimento-principal') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao.usuario_executante_id', 'cadastro_usuario.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                        ->when($params->unidade_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                    );
                }
                else if ($tipoInconsistencia === 'procedimento-secundario') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao_procedimento_secundario',
                            'apac_solicitacao_autorizacao_procedimento_secundario.id',
                            'apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id'
                        )
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_procedimento_secundario.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao.usuario_executante_id', 'cadastro_usuario.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                        ->when($params->unidade_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                    );
                }
            });
    }

    private static function getOcupacoes($params)
    {
        return DB::table('sigtap.ocupacao')
            ->select([
                'ocupacao.id',
                DB::raw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) as descricao"),
            ])
            ->when($params->tipo_inconsistencia, function ($query, $tipoInconsistencia) use ($params) {
                if ($tipoInconsistencia === 'procedimento-principal') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao.procedimento_principal_ocupacao_id', 'ocupacao.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                        ->when($params->unidade_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                        ->when($params->usuario_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.usuario_executante_id', $id))
                    );
                }
                else if ($tipoInconsistencia === 'procedimento-secundario') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao_procedimento_secundario',
                            'apac_solicitacao_autorizacao_procedimento_secundario.id',
                            'apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id'
                        )
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_procedimento_secundario.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao_procedimento_secundario.ocupacao_id', 'ocupacao.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                        ->when($params->unidade_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                        ->when($params->usuario_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.usuario_executante_id', $id))
                    );
                }
            })
            ->orderByRaw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)")
            ->get();
    }

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

        return DB::table('sigtap.procedimento')
            ->select([
                'procedimento.id',
                'procedimento.codigo',
                'procedimento.nome'
            ])
            ->when($params->tipo_inconsistencia, function ($query, $tipoInconsistencia) use ($params) {
                if ($tipoInconsistencia === 'procedimento-principal') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao.procedimento_principal_id', 'procedimento.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                        ->when($params->unidade_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                        ->when($params->usuario_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.usuario_executante_id', $id))
                        ->when($params->ocupacao_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.procedimento_principal_ocupacao_id', $id))
                    );
                }
                else if ($tipoInconsistencia === 'procedimento-secundario') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao_procedimento_secundario',
                            'apac_solicitacao_autorizacao_procedimento_secundario.id',
                            'apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id'
                        )
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_procedimento_secundario.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao_procedimento_secundario.procedimento_id', 'procedimento.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                        ->when($params->unidade_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                        ->when($params->usuario_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.usuario_executante_id', $id))
                        ->when($params->ocupacao_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao_procedimento_secundario.ocupacao_id', $id))
                    );
                }
            });
    }

    private static function getCids($params)
    {
        return DB::table('sigtap.cid')
            ->select([
                'cid.id',
                'cid.codigo',
                'cid.nome'
            ])
            ->when($params->tipo_inconsistencia, function ($query, $tipoInconsistencia) use ($params) {
                if ($tipoInconsistencia === 'procedimento-principal') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_inconsistencia.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao.procedimento_principal_cid_principal_id', 'cid.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                        ->when($params->unidade_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                        ->when($params->usuario_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.usuario_executante_id', $id))
                        ->when($params->ocupacao_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.procedimento_principal_ocupacao_id', $id))
                        ->when($params->procedimento_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.procedimento_principal_id', $id))
                    );
                }
                else if ($tipoInconsistencia === 'procedimento-secundario') {
                    $query->whereExists(fn($q) => $q->select(DB::raw(1))
                        ->from('apac_solicitacao_autorizacao_procedimento_secund_inconsistencia')
                        ->join(
                            'apac_solicitacao_autorizacao_procedimento_secundario',
                            'apac_solicitacao_autorizacao_procedimento_secundario.id',
                            'apac_solicitacao_autorizacao_procedimento_secund_inconsistencia.procedimento_secundario_id'
                        )
                        ->join(
                            'apac_solicitacao_autorizacao',
                            'apac_solicitacao_autorizacao.id',
                            'apac_solicitacao_autorizacao_procedimento_secundario.solicitacao_autorizacao_id'
                        )
                        ->whereColumn('apac_solicitacao_autorizacao_procedimento_secundario.cid_principal_id', 'cid.id')
                        ->where('apac_solicitacao_autorizacao.competencia_id', $params->competencia_id)
                        ->when($params->unidade_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.unidade_executante_id', $id))
                        ->when($params->usuario_executante_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao.usuario_executante_id', $id))
                        ->when($params->ocupacao_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao_procedimento_secundario.ocupacao_id', $id))
                        ->when($params->procedimento_id, fn ($q, $id) => $q
                            ->where('apac_solicitacao_autorizacao_procedimento_secundario.procedimento_id', $id))
                    );
                }
            })
            ->orderByRaw("CONCAT(cid.codigo, ' - ', cid.nome)")
            ->get()
            ->map(fn ($cid) => [
                'id' => $cid->id,
                'descricao' => MaskUtil::getCidMasked($cid->codigo) . " - {$cid->nome}",
            ]);
    }

    private static function setOrderBy($builder)
    {
        $columns = [
            'data_processamento' => 'apac_solicitacao_autorizacao.data_processamento',
            'prontuario' => 'cadastro_paciente.prontuario',
            'paciente_nome' => 'paciente_cidadao.nome',
            'unidade_executante_nome_fantasia' => 'cadastro_unidade.nome_fantasia',
            'usuario_executante_nome' => 'usuario_cidadao.nome',
            'ocupacao_codigo' => 'ocupacao.codigo',
            'procedimento_descricao' => "CONCAT(procedimento.codigo, ' - ', procedimento.nome)",
            'cid_descricao' => "CONCAT(cid.codigo, ' - ', cid.nome)",
        ];

        if (is_null(request()->sort_by)) {
            $builder->orderByRaw(join(', ', $columns));

            return;
        }

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

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

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