<?php

namespace App\Services\Regulacao;

use App\Enums\Ambulatorio\AcompanhamentoOciStatus;
use App\Enums\Ambulatorio\AgendamentoStatus as AgendamentoStatusEnum;
use App\Enums\Cadastro\EtapaClinica;
use App\Enums\Cadastro\SujeitoAtencao\TipoRegistroUsuario;
use App\Enums\ExameImagem\Fechamento\Status as ExameImagemAgendamentoStatus;
use App\Enums\ExameLaboratorial\Acao;
use App\Enums\ExameLaboratorial\StatusAgendamento as ExameLaboratorialAgendamentoStatus;
use App\Enums\Parametrizacao\Exame\Tipo as ExameTipo;
use App\Enums\Parametrizacao\Exame\Tipo as TipoExame;
use App\Enums\Regulacao\OpcaoRetiradaProtocoloAgendamento;
use App\Enums\Regulacao\SolicitacaoPrioridade;
use App\Enums\Regulacao\StatusTipo;
use App\Enums\Regulacao\Tipo;
use App\Enums\Regulacao\TipoAgendamento;
use App\Enums\Regulacao\TipoAgendamentoModulo;
use App\Enums\Sigtap\Complexidade;
use App\Exceptions\Regulacao\CannotUpdateSolicitacaoException;
use App\Http\Controllers\Cadastro\SujeitoAtencao\PacienteController;
use App\Models\Ambulatorio\AcompanhamentoOci;
use App\Models\Ambulatorio\Agendamento as AgendamentoAmbulatorio;
use App\Models\Ambulatorio\ParametrizacaoAgendamento as AmbulatorioParametrizacaoAgendamento;
use App\Models\Cadastro\Especialidade;
use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\EtapaClinica as EtapaClinicaEnum;
use App\Models\Cadastro\Grupo\Grupo;
use App\Models\Cadastro\Oci;
use App\Models\Cadastro\Parametrizacao\Parametrizacao as CadastroParametrizacao;
use App\Models\Cadastro\SujeitoAtencao\Cidadao;
use App\Models\Cadastro\SujeitoAtencao\Lotacao;
use App\Models\Cadastro\SujeitoAtencao\Paciente;
use App\Models\Cadastro\SujeitoAtencao\PacienteHistorico;
use App\Models\Cadastro\SujeitoAtencao\Sexo;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\ExameImagem\Agendamento\Agendamento as AgendamentoExameImagem;
use App\Models\ExameImagem\Agendamento\AgendamentoExame as ExameImagemAgendamentoExame;
use App\Models\ExameLaboratorial\AgendamentoExame\Agendamento as AgendamentoExame;
use App\Models\ExameLaboratorial\AgendamentoExame\AgendamentoExame as ExameLaboratorialAgendamentoExame;
use App\Models\Geral\Ciap;
use App\Models\Intranet\Cliente;
use App\Models\Parametrizacao\Exame\Exame;
use App\Models\Parametrizacao\ProcedimentoCirurgico;
use App\Models\Regulacao\Parametrizacao;
use App\Models\Regulacao\ParametrizacaoOpcaoRetiradaProtocoloAgendamento;
use App\Models\Regulacao\ParametrizacaoPrestadorExterno;
use App\Models\Regulacao\ParametrizacaoPrestadorInterno;
use App\Models\Regulacao\ParametrizacaoRegulador;
use App\Models\Regulacao\ParametrizacaoSolicitanteRegulador;
use App\Models\Regulacao\ParametrizacaoSupervisor;
use App\Models\Regulacao\Solicitacao;
use App\Models\Regulacao\SolicitacaoItem;
use App\Models\Regulacao\SolicitacaoPrioridade as RegulacaoSolicitacaoPrioridade;
use App\Models\Regulacao\SolicitacaoTentativaContato;
use App\Models\Regulacao\Status;
use App\Models\Sigtap\Cid;
use App\Models\Sigtap\Ocupacao;
use App\Rules\Cns;
use App\Rules\Cpf;
use App\Services\Ambulatorio\AgendamentoService as AmbulatorioAgendamentoService;
use App\Services\Ambulatorio\HistoricoAtendimentoService as historicoAtendimento;
use App\Services\Cadastro\SujeitoAtencao\CidadaoService;
use App\Services\ExameImagem\ImpressaoService as ImpressaoExameImagemService;
use App\Services\ExameImagem\SmsService;
use App\Services\ExameLaboratorial\AgendamentoExameHistoricoService;
use App\Services\ExameLaboratorial\ImpressaoService as ImpressaoExameLaboratorialService;
use App\Services\Geral\AgeService;
use App\Services\Service;
use App\Utils\DataUtil;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use DateTime;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;

class FilaService extends Service
{
    public static function autocompletePaciente()
    {
        return DB::table('cadastro_paciente as paciente')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'paciente.cidadao_id')
            ->whereNull('paciente.deleted_at')
            ->selectRaw("
                paciente.id,
                cidadao.nome,
                cidadao.nome_social,
                cidadao.cns
            ");
    }

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

        $params = self::getParams();

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

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

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

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

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

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

                $params->paciente_id = null;
            },
            'idade_de' => function () use ($data, $params) {

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

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

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

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

                $unidadeReguladoraData = self::getUnidadesReguladoras(
                    $params,
                    null
                );

                $data->form['unidades_reguladoras'] = $unidadeReguladoraData['form'];
                $data->model['unidade_reguladora_id'] = $unidadeReguladoraData['model'];

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

                $reguladorData = self::getReguladores(
                    $params,
                    null
                );

                $data->form['reguladores'] = $reguladorData['form'];
                $data->model['regulador_id'] = $reguladorData['model'];

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

                $unidadeSolicitanteData = self::getUnidadesSolicitantes(
                    $params,
                    null
                );

                $data->form['unidades_solicitantes'] = $unidadeSolicitanteData['form'];
                $data->model['unidade_solicitante_id'] = $unidadeSolicitanteData['model'];

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

                $infraestruturaSolicitanteData = self::getInfraestruturasSolicitantes(
                    $params,
                    null
                );

                $data->form['infraestruturas_solicitantes'] = $infraestruturaSolicitanteData['form'];
                $data->model['infraestrutura_solicitante_id'] = $infraestruturaSolicitanteData['model'];

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

                $usuarioReferenciaData = self::getUnidadesReferencia(
                    $params,
                    null
                );

                $data->form['unidades_referencia'] = $usuarioReferenciaData['form'];
                $data->model['unidade_referencia_id'] = $usuarioReferenciaData['model'];

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

                $usuarioSolicitanteData = self::getUsuariosSolicitantes($params);

                $data->form['usuarios_solicitantes'] = $usuarioSolicitanteData['form'];
                $data->model['usuario_solicitante_id'] = $usuarioSolicitanteData['model'];

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

                $prestadorData = self::getPrestadores($params);

                $data->form['prestadores'] = $prestadorData['form'];
                $data->model['prestador'] = $prestadorData['model'];

                $params->prestador = $data->model['prestador'];

                self::setParamsPrestador($params);
            },
            'status' => function () use ($data, $params) {

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

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

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

                $opcaoData = self::getOpcoesRetiradasProtocoloAgendamento($params);

                $data->form['opcoes_retirada_protocolo_agendamento'] = $opcaoData['form'];
                $data->model['opcao_retirada_protocolo_agendamento_id'] = $opcaoData['model'];

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

                $grupoData = self::getGrupos($params);

                $data->form['grupos'] = $grupoData['form'];
                $data->model['grupos'] = $grupoData['model'];

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

                $exameData = self::getExames($params);

                $data->form['exames'] = $exameData['form'];
                $data->model['exames'] = $exameData['model'];

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

                $procedimentoCirurgicoData = self::getProcedimentosCirurgicos($params);

                $data->form['procedimentos_cirurgicos'] = $procedimentoCirurgicoData['form'];
                $data->model['procedimentos_cirurgicos'] = $procedimentoCirurgicoData['model'];

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

                $especialidadeData = self::getEspecialidades($params);

                $data->form['especialidades'] = $especialidadeData['form'];
                $data->model['especialidades'] = $especialidadeData['model'];

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

                $prioridadeData = self::getPrioridades($params);

                $data->form['prioridades'] = $prioridadeData['form'];
                $data->model['prioridades'] = $prioridadeData['model'];

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

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

                $params->cid_id = $data->model['cid'];
            },
            'ciap' => function () use ($data, $params) {

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

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

                $sexoData = self::getSexos($params);

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

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

                $ociData = self::getOcis($params);

                $data->form['ocis'] = $ociData['form'];
                $data->model['oci_id'] = $ociData['model'];

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

                $etapaClinicaData = self::getEtapasClinicas($params);

                $data->form['etapas_clinicas'] = $etapaClinicaData['form'];
                $data->model['etapa_clinica_id'] = $etapaClinicaData['model'];

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

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

        if ($load) {

            $data->additionals = [
                'data_atual' => Carbon::today()->format('d/m/Y'),
                'has_status_em_espera' => Status::where('tipo_id', StatusTipo::EM_ESPERA)->exists(),
                'is_supervisor' => self::isSupervisor(),
            ];
        }

        $fieldsItem = collect(['exame', 'procedimento_cirurgico', 'especialidade']);
        $isLoadFromItens = $fieldsItem->contains(request()->load_from);

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

            if ($load) {

                if ($isLoadFromItens && $fieldsItem->contains($field)) {

                    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 getPermitidos()
    {
        $lotacaoLogada = self::getCurrentLotacao();
        $reguladorLogado = self::getReguladorLogado();

        $reguladoresPermitidos = self::getReguladoresDoSolicitanteOuReferenciaLogado();
        $solicitantesPermitidos = collect();
        $unidadesReferenciaPermitidas = collect();

        if (!is_null($reguladorLogado)) {

            if (is_null($reguladoresPermitidos->where('id', $reguladorLogado->id)->first())) {

                $reguladoresPermitidos->push($reguladorLogado);
            }

            $solicitantesPermitidos = self::getSolicitantesDoRegulador($reguladorLogado);
        }

        $solicitantesPermitidos = $solicitantesPermitidos
            ->concat(self::getSolicitantesDaUnidadeReferenciaLogada())
            ->unique('infraestrutura_id')
            ->values();

        if (is_null($solicitantesPermitidos->where('infraestrutura_id', $lotacaoLogada->infraestrutura_id)->first())) {

            $solicitantesPermitidos->push((object) [
                'infraestrutura_id' => $lotacaoLogada->infraestrutura_id,
                'unidade_id' => $lotacaoLogada->infraestrutura->unidade_id,
            ]);
        }

        $unidadesReferenciaPermitidas = self::getUnidadesReferenciaDosSolicitantes(
            $reguladoresPermitidos,
            $solicitantesPermitidos
        );

        if (is_null($unidadesReferenciaPermitidas->where('id', $lotacaoLogada->infraestrutura->unidade_id)->first())) {

            $unidadesReferenciaPermitidas->push((object) [
                'id' => $lotacaoLogada->infraestrutura->unidade_id,
            ]);
        }

        return [
            'reguladores_permitidos' => $reguladoresPermitidos,
            'solicitantes_permitidos' => $solicitantesPermitidos,
            'unidades_referencia_permitidas' => $unidadesReferenciaPermitidas,
        ];
    }

    private static function getReguladoresDoSolicitanteOuReferenciaLogado()
    {
        $centroCustoLogado = self::getCurrentCentroCusto();

        return ParametrizacaoRegulador::whereHas('solicitacoes', fn ($q) => $q
                ->whereNotNull('confirmado_em')
                ->where(fn ($q) => $q
                    ->where('infraestrutura_solicitante_id', $centroCustoLogado->infraestrutura_id)
                    ->orWhereHas('paciente', fn ($q) => $q
                        ->where('unidade_id', $centroCustoLogado->infraestrutura->unidade_id)
                    )
                )
            )
            ->get()
            ->map(fn ($regulador) => (object) [
                'id' => $regulador->id,
                'unidade_id' => $regulador->infraestrutura->unidade_id,
            ]);
    }

    private static function getReguladorLogado()
    {
        return ParametrizacaoRegulador::where('infraestrutura_id', self::getCurrentCentroCusto()->infraestrutura_id)
            ->get()
            ->map(fn ($regulador) => (object) [
                'id' => $regulador->id,
                'unidade_id' => $regulador->infraestrutura->unidade_id,
            ])
            ->first();
    }

    private static function getSolicitantesDoRegulador($regulador)
    {
        return ParametrizacaoSolicitanteRegulador::where('regulador_id', $regulador->id)
            ->get()
            ->map(fn ($solicitanteRegulador) => (object) [
                'infraestrutura_id' => optional($solicitanteRegulador->solicitante)->infraestrutura_id,
                'unidade_id' => optional(optional($solicitanteRegulador->solicitante)->infraestrutura)->unidade_id,
            ]);
    }

    private static function getSolicitantesDaUnidadeReferenciaLogada()
    {
        return DB::table('cadastro_infraestrutura as infraestrutura')
            ->whereNull('infraestrutura.deleted_at')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('regulacao_solicitacao as solicitacao')
                ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                ->whereColumn('solicitacao.infraestrutura_solicitante_id', 'infraestrutura.id')
                ->whereNotNull('solicitacao.confirmado_em')
                ->where('paciente.unidade_id', self::getCurrentCentroCusto()->infraestrutura->unidade_id)
            )
            ->selectRaw("
                infraestrutura.id as infraestrutura_id,
                infraestrutura.unidade_id
            ")
            ->get();
    }

    private static function getUnidadesReferenciaDosSolicitantes($reguladores, $solicitantes)
    {
        return DB::table('cadastro_unidade as unidade')
            ->whereNull('unidade.deleted_at')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_paciente as paciente')
                ->whereColumn('paciente.unidade_id', 'unidade.id')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->whereColumn('solicitacao.paciente_id', 'paciente.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->whereIn('solicitacao.regulador_id', $reguladores->pluck('id'))
                    ->whereIn('solicitacao.infraestrutura_solicitante_id', $solicitantes->pluck('infraestrutura_id'))
                )
            )
            ->select('unidade.id')
            ->get();
    }

    private static function getParams()
    {
        $params = (object) [
            'periodo' => request()->get('periodo', ['start' => null, 'end' => null]),
            'periodo_movimentacao' => request()->get('periodo_movimentacao', ['start' => null, 'end' => null]),
            'paciente_id' => request()->get('paciente_id'),
            'unidade_reguladora_id' => request()->get('unidade_reguladora_id'),
            'regulador_id' => request()->get('regulador_id'),
            'unidade_solicitante_id' => request()->get('unidade_solicitante_id'),
            'infraestrutura_solicitante_id' => request()->get('infraestrutura_solicitante_id'),
            'usuario_solicitante_id' => request()->get('usuario_solicitante_id'),
            'unidade_referencia_id' => request()->get('unidade_referencia_id'),
            'prestador' => request()->get('prestador'),
            'status' => request()->get('status', []),
            'opcao_retirada_protocolo_agendamento_id' => request()->get('opcao_retirada_protocolo_agendamento_id'),
            'grupos' => request()->get('grupos', []),
            'exames' => request()->get('exames', []),
            'procedimentos_cirurgicos' => request()->get('procedimentos_cirurgicos', []),
            'especialidades' => request()->get('especialidades', []),
            'prioridades' => request()->get('prioridades', []),
            'cid_id' => request()->get('cid_id'),
            'ciap_id' => request()->get('ciap_id'),
            'sexo_id' => request()->get('sexo_id'),
            'oci_id' => request()->get('oci_id'),
            'etapa_clinica_id' => request()->get('etapa_clinica_id'),
            'idade_de' => request()->get('idade_de'),
            'idade_ate' => request()->get('idade_ate'),
        ];

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

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

        self::setParamsPrestador($params);

        return $params;
    }

    private static function setParamsPrestador($params)
    {
        $params->nenhum_prestador = $params->prestador === 'nenhum';
        $params->prestador_interno_id = null;
        $params->prestador_externo_id = null;

        if (!is_null($params->prestador) && !$params->nenhum_prestador) {

            $prestadorData = explode('#', $params->prestador);
            $params->{"prestador_{$prestadorData[0]}_id"} = $prestadorData[1];
        }

        unset($params->prestador);
    }

    private static function getUnidadesReguladoras($params, $unidadesIds = null)
    {
        $unidadesReguladoras = DB::table('cadastro_unidade as unidade')
            ->whereNull('unidade.deleted_at')
            ->when($unidadesIds, fn ($q, $ids) => $q->whereIn('unidade.id', $ids))
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_infraestrutura as infraestrutura')
                ->join(
                    'regulacao_parametrizacao_regulador as regulador',
                    'regulador.infraestrutura_id',
                    'infraestrutura.id'
                )
                ->whereColumn('infraestrutura.unidade_id', 'unidade.id')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->whereColumn('solicitacao.regulador_id', 'regulador.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                )
            )
            ->selectRaw("
                unidade.id,
                unidade.nome_fantasia
            ")
            ->orderBy('unidade.nome_fantasia')
            ->get();

        $id = $unidadesReguladoras->count() === 1 ? $unidadesReguladoras->first()->id : null;

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

    private static function getReguladores($params, $reguladoresIds = null)
    {
        $reguladores = collect();

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

            $reguladores = DB::table('regulacao_parametrizacao_regulador as regulador')
                ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'regulador.infraestrutura_id')
                ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
                ->where('infraestrutura.unidade_id', $params->unidade_reguladora_id)
                ->when($reguladoresIds, fn ($q, $ids) => $q->whereIn('regulador.id', $ids))
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->whereColumn('solicitacao.regulador_id', 'regulador.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                )
                ->selectRaw("
                    regulador.id,
                    COALESCE(infraestrutura.nome, unidade.nome_fantasia) as nome
                ")
                ->orderByRaw("COALESCE(infraestrutura.nome, unidade.nome_fantasia)")
                ->get();
        }

        $id = $reguladores->count() === 1 ? $reguladores->first()->id : null;

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

    private static function getUnidadesSolicitantes($params, $unidadesIds = null)
    {
        $unidadesSolicitantes = DB::table('cadastro_unidade as unidade')
            ->whereNull('unidade.deleted_at')
            ->when($unidadesIds, fn ($q, $ids) => $q->whereIn('unidade.id', $ids))
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_infraestrutura as infraestrutura_solicitante')
                ->whereColumn('infraestrutura_solicitante.unidade_id', 'unidade.id')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->whereColumn('solicitacao.infraestrutura_solicitante_id', 'infraestrutura_solicitante.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                )
            )
            ->selectRaw("
                unidade.id,
                unidade.nome_fantasia
            ")
            ->orderBy('unidade.nome_fantasia')
            ->get();

        $id = $unidadesSolicitantes->count() === 1
            ? $unidadesSolicitantes->first()->id
            : null;

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

    private static function getInfraestruturasSolicitantes($params, $infraestruturasIds = null)
    {
        $infraestruturasSolicitantes = collect();
        $id = null;

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

            $infraestruturasSolicitantes = 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_solicitante_id)
                ->when($infraestruturasIds, fn ($q, $ids) => $q->whereIn('infraestrutura.id', $ids))
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->whereColumn('solicitacao.infraestrutura_solicitante_id', 'infraestrutura.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                )
                ->selectRaw("
                    infraestrutura.id,
                    COALESCE(infraestrutura.nome, unidade.nome_fantasia) as nome
                ")
                ->orderByRaw("COALESCE(infraestrutura.nome, unidade.nome_fantasia)")
                ->get();

            if (!is_null($infraestruturasIds) && $infraestruturasSolicitantes->count() === 1) {

                $id = $infraestruturasSolicitantes->first()->id;
            }
        }

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

    private static function getUnidadesReferencia($params, $unidadesIds = null)
    {
        $unidadesReferencia = DB::table('cadastro_unidade as unidade')
            ->whereNull('unidade.deleted_at')
            ->when($unidadesIds, fn ($q, $ids) => $q->whereIn('unidade.id', $ids))
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_paciente as paciente')
                ->whereColumn('paciente.unidade_id', 'unidade.id')
                ->when($params->paciente_id, fn ($q, $id) => $q->where('paciente.id', $id))
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->whereColumn('solicitacao.paciente_id', 'paciente.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                )
            )
            ->selectRaw("
                unidade.id,
                unidade.nome_fantasia
            ")
            ->orderBy('unidade.nome_fantasia')
            ->get();

        $id = $unidadesReferencia->count() === 1
            ? $unidadesReferencia->first()->id
            : null;

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

    private static function getUsuariosSolicitantes($params)
    {
        $usuariosSolicitantes = collect();

        if (!is_null($params->regulador_id) || !is_null($params->infraestrutura_solicitante_id) || !is_null($params->unidade_referencia_id)) {

            $usuariosSolicitantes = 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('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->whereColumn('solicitacao.usuario_solicitante_id', 'usuario.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                )
                ->selectRaw("
                    usuario.id,
                    cidadao.nome
                ")
                ->orderBy('cidadao.nome')
                ->get();
        }

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

    private static function getPrestadores($params)
    {
        $prestadores = collect();

        if (!is_null($params->unidade_reguladora_id) || !is_null($params->regulador_id) || !is_null($params->infraestrutura_solicitante_id) || !is_null($params->unidade_referencia_id)) {

            $prestadores = DB::query()
                ->fromSub(DB::table('regulacao_parametrizacao_prestador_interno as prestador_interno')
                    ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'prestador_interno.infraestrutura_id')
                    ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao as solicitacao')
                        ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                            ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                            ->where('movimentacao.id', fn ($q) => $q
                                ->select('movimentacao2.id')
                                ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                                ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                                ->orderByDesc('movimentacao2.id')
                                ->limit(1)
                            )
                        )
                        ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                        ->join(
                            'regulacao_parametrizacao_regulador as regulador',
                            'regulador.id',
                            'solicitacao.regulador_id'
                        )
                        ->join(
                            'cadastro_infraestrutura as infraestrutura_reguladora',
                            'infraestrutura_reguladora.id',
                            'regulador.infraestrutura_id'
                        )
                        ->join(
                            'cadastro_infraestrutura as infraestrutura_solicitante',
                            'infraestrutura_solicitante.id',
                            'solicitacao.infraestrutura_solicitante_id'
                        )
                        ->whereColumn('solicitacao.prestador_interno_id', 'prestador_interno.id')
                        ->whereNotNull('solicitacao.prestador_interno_id')
                        ->whereNotNull('solicitacao.confirmado_em')
                        ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                        ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                        ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                        ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                        ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                        ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                        ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                        ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                        ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                        ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                        ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    )
                    ->selectRaw("
                        'interno' as tipo,
                        prestador_interno.id,
                        IF(infraestrutura.principal = 1,
                            unidade.nome_fantasia,
                            CONCAT(unidade.nome_fantasia, ' - ', infraestrutura.nome)
                        ) as nome
                    ")
                    ->unionAll(DB::table('regulacao_parametrizacao_prestador_externo as prestador_externo')
                        ->join('transporte_paciente_destino as destino', 'destino.id', 'prestador_externo.destino_id')
                        ->whereExists(fn ($q) => $q
                            ->selectRaw(1)
                            ->from('regulacao_solicitacao as solicitacao')
                            ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                                ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                                ->where('movimentacao.id', fn ($q) => $q
                                    ->select('movimentacao2.id')
                                    ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                                    ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                                    ->orderByDesc('movimentacao2.id')
                                    ->limit(1)
                                )
                            )
                            ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                            ->join(
                                'regulacao_parametrizacao_regulador as regulador',
                                'regulador.id',
                                'solicitacao.regulador_id'
                            )
                            ->join(
                                'cadastro_infraestrutura as infraestrutura_reguladora',
                                'infraestrutura_reguladora.id',
                                'regulador.infraestrutura_id'
                            )
                            ->join(
                                'cadastro_infraestrutura as infraestrutura_solicitante',
                                'infraestrutura_solicitante.id',
                                'solicitacao.infraestrutura_solicitante_id'
                            )
                            ->whereColumn('solicitacao.prestador_externo_id', 'prestador_externo.id')
                            ->whereNotNull('solicitacao.prestador_externo_id')
                            ->whereNotNull('solicitacao.confirmado_em')
                            ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                            ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                            ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                            ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                            ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                            ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                            ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                            ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                            ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                            ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                            ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                        )
                        ->selectRaw("
                            'externo' as tipo,
                            prestador_externo.id,
                            destino.descricao_destino as nome
                        ")
                    )
                , 'prestador')
                ->selectRaw("
                    CONCAT(prestador.tipo, '#', prestador.id) as value,
                    prestador.nome
                ")
                ->orderBy('prestador.nome')
                ->get();
        }

        $prestadores = collect([(object) ['value' => 'nenhum', 'nome' => 'Nenhum']])->merge($prestadores);

        return ['form' => $prestadores, 'model' => 'nenhum'];
    }

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

        if (!is_null($params->regulador_id) || !is_null($params->infraestrutura_solicitante_id) || !is_null($params->unidade_referencia_id) || !is_null($params->paciente_id)) {

            $status = DB::table('regulacao_status as status')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->leftJoin(
                        'regulacao_parametrizacao_prestador_interno as prestador_interno',
                        'prestador_interno.id',
                        'solicitacao.prestador_interno_id'
                    )
                    ->leftJoin(
                        'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                        'infraestrutura_prestadora_interna.id',
                        'prestador_interno.infraestrutura_id'
                    )
                    ->whereColumn('solicitacao.status_id', 'status.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                )
                ->selectRaw("
                    status.id,
                    status.tipo_id,
                    status.nome
                ")
                ->orderBy('status.nome')
                ->get();

            $ids = $status->pluck('id');
        }

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

    private static function getOpcoesRetiradasProtocoloAgendamento($params)
    {
        $opcoes = collect();

        if (!empty($params->status)) {

            $opcoes = DB::table('regulacao_parametrizacao_opcao_retirada_protocolo_agendamento as opcao')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->leftJoin(
                        'regulacao_parametrizacao_prestador_interno as prestador_interno',
                        'prestador_interno.id',
                        'solicitacao.prestador_interno_id'
                    )
                    ->leftJoin(
                        'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                        'infraestrutura_prestadora_interna.id',
                        'prestador_interno.infraestrutura_id'
                    )
                    ->whereColumn('solicitacao.opcao_retirada_protocolo_agendamento_id', 'opcao.id')
                    ->whereNotNull('solicitacao.opcao_retirada_protocolo_agendamento_id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                    ->whereIn('solicitacao.status_id', $params->status)
                )
                ->selectRaw("
                    opcao.id,
                    opcao.nome
                ")
                ->orderBy('opcao.nome')
                ->get();
        }

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

    private static function getGrupos($params)
    {
        $grupos = collect();

        if (!empty($params->status)) {

            $grupos = DB::table('cadastro_grupo as grupo')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('parametrizacao_exame as exame')
                    ->whereColumn('exame.grupo_tipo_id', 'grupo.id')
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao_item as item')
                        ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'item.solicitacao_id')
                        ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                            ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                            ->where('movimentacao.id', fn ($q) => $q
                                ->select('movimentacao2.id')
                                ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                                ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                                ->orderByDesc('movimentacao2.id')
                                ->limit(1)
                            )
                        )
                        ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                        ->join(
                            'regulacao_parametrizacao_regulador as regulador',
                            'regulador.id',
                            'solicitacao.regulador_id'
                        )
                        ->join(
                            'cadastro_infraestrutura as infraestrutura_reguladora',
                            'infraestrutura_reguladora.id',
                            'regulador.infraestrutura_id'
                        )
                        ->join(
                            'cadastro_infraestrutura as infraestrutura_solicitante',
                            'infraestrutura_solicitante.id',
                            'solicitacao.infraestrutura_solicitante_id'
                        )
                        ->leftJoin(
                            'regulacao_parametrizacao_prestador_interno as prestador_interno',
                            'prestador_interno.id',
                            'solicitacao.prestador_interno_id'
                        )
                        ->leftJoin(
                            'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                            'infraestrutura_prestadora_interna.id',
                            'prestador_interno.infraestrutura_id'
                        )
                        ->whereColumn('item.exame_id', 'exame.id')
                        ->whereNotNull('item.exame_id')
                        ->whereNotNull('solicitacao.confirmado_em')
                        ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                        ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                        ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                        ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                        ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                        ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                        ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                        ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                        ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                        ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                        ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                        ->when($params->nenhum_prestador, fn ($q) => $q
                            ->whereNull('solicitacao.prestador_interno_id')
                            ->whereNull('solicitacao.prestador_externo_id')
                        )
                        ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                        ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                        ->whereIn('solicitacao.status_id', $params->status)
                        ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                            ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                        )
                    )
                )
                ->orWhereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('parametrizacao_procedimento_cirurgico as procedimento_cirurgico')
                    ->whereColumn('procedimento_cirurgico.grupo_exame_id', 'grupo.id')
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao_item as item')
                        ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'item.solicitacao_id')
                        ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                            ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                            ->where('movimentacao.id', fn ($q) => $q
                                ->select('movimentacao2.id')
                                ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                                ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                                ->orderByDesc('movimentacao2.id')
                                ->limit(1)
                            )
                        )
                        ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                        ->join(
                            'regulacao_parametrizacao_regulador as regulador',
                            'regulador.id',
                            'solicitacao.regulador_id'
                        )
                        ->join(
                            'cadastro_infraestrutura as infraestrutura_reguladora',
                            'infraestrutura_reguladora.id',
                            'regulador.infraestrutura_id'
                        )
                        ->join(
                            'cadastro_infraestrutura as infraestrutura_solicitante',
                            'infraestrutura_solicitante.id',
                            'solicitacao.infraestrutura_solicitante_id'
                        )
                        ->leftJoin(
                            'regulacao_parametrizacao_prestador_interno as prestador_interno',
                            'prestador_interno.id',
                            'solicitacao.prestador_interno_id'
                        )
                        ->leftJoin(
                            'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                            'infraestrutura_prestadora_interna.id',
                            'prestador_interno.infraestrutura_id'
                        )
                        ->whereColumn('item.procedimento_cirurgico_id', 'procedimento_cirurgico.id')
                        ->whereNotNull('item.procedimento_cirurgico_id')
                        ->whereNotNull('solicitacao.confirmado_em')
                        ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                        ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                        ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                        ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                        ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                        ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                        ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                        ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                        ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                        ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                        ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                        ->when($params->nenhum_prestador, fn ($q) => $q
                            ->whereNull('solicitacao.prestador_interno_id')
                            ->whereNull('solicitacao.prestador_externo_id')
                        )
                        ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                        ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                        ->whereIn('solicitacao.status_id', $params->status)
                        ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                            ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                        )
                    )
                )
                ->selectRaw("
                    grupo.id,
                    grupo.nome
                ")
                ->orderBy('grupo.nome')
                ->get();
        }

        $ids = $grupos->pluck('id')->all();

        return ['form' => $grupos, 'model' => $ids];
    }

    private static function getExames($params)
    {
        $exames = collect();

        if (!empty($params->grupos)) {

            $exames = DB::table('parametrizacao_exame as exame')
                ->whereNull('exame.deleted_at')
                ->whereIn('exame.grupo_tipo_id', $params->grupos)
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao_item as item')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'item.solicitacao_id')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->leftJoin(
                        'regulacao_parametrizacao_prestador_interno as prestador_interno',
                        'prestador_interno.id',
                        'solicitacao.prestador_interno_id'
                    )
                    ->leftJoin(
                        'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                        'infraestrutura_prestadora_interna.id',
                        'prestador_interno.infraestrutura_id'
                    )
                    ->whereColumn('item.exame_id', 'exame.id')
                    ->whereNotNull('item.exame_id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                    ->whereIn('solicitacao.status_id', $params->status)
                    ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                        ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                    )
                )
                ->selectRaw("
                    exame.id,
                    exame.codigo,
                    exame.nome
                ")
                ->orderByRaw("exame.nome")
                ->get()
                ->map(fn ($exame) => [
                    'id' => $exame->id,
                    'descricao' => empty($exame->codigo)
                        ? $exame->nome
                        : MaskUtil::getProcedimentoMasked($exame->codigo) . " - {$exame->nome}",
                ]);
        }

        $ids = $exames->pluck('id')->all();

        return ['form' => $exames, 'model' => $ids];
    }

    private static function getProcedimentosCirurgicos($params)
    {
        $procedimentosCirurgicos = collect();

        if (!empty($params->grupos)) {

            $procedimentosCirurgicos =  DB::table('parametrizacao_procedimento_cirurgico as procedimento_cirurgico')
                ->whereIn('procedimento_cirurgico.grupo_exame_id', $params->grupos)
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao_item as item')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'item.solicitacao_id')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->leftJoin(
                        'regulacao_parametrizacao_prestador_interno as prestador_interno',
                        'prestador_interno.id',
                        'solicitacao.prestador_interno_id'
                    )
                    ->leftJoin(
                        'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                        'infraestrutura_prestadora_interna.id',
                        'prestador_interno.infraestrutura_id'
                    )
                    ->whereColumn('item.procedimento_cirurgico_id', 'procedimento_cirurgico.id')
                    ->whereNotNull('item.procedimento_cirurgico_id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                    ->whereIn('solicitacao.status_id', $params->status)
                    ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                        ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                    )
                )
                ->selectRaw("
                    procedimento_cirurgico.id,
                    procedimento_cirurgico.procedimento_codigo as codigo,
                    procedimento_cirurgico.nome
                ")
                ->orderByRaw("procedimento_cirurgico.nome")
                ->get()
                ->map(fn ($procedimentoCirurgico) => [
                    'id' => $procedimentoCirurgico->id,
                    'descricao' => MaskUtil::getProcedimentoMasked($procedimentoCirurgico->codigo)
                        . " - {$procedimentoCirurgico->nome}",
                ]);
        }

        $ids = $procedimentosCirurgicos->pluck('id')->all();

        return ['form' => $procedimentosCirurgicos, 'model' => $ids];
    }

    private static function getEspecialidades($params)
    {
        $especialidades = collect();

        if (!empty($params->status)) {

            $especialidades = DB::table('cadastro_especialidade as especialidade')
                ->join('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao_item as item')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'item.solicitacao_id')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->leftJoin(
                        'regulacao_parametrizacao_prestador_interno as prestador_interno',
                        'prestador_interno.id',
                        'solicitacao.prestador_interno_id'
                    )
                    ->leftJoin(
                        'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                        'infraestrutura_prestadora_interna.id',
                        'prestador_interno.infraestrutura_id'
                    )
                    ->whereColumn('item.especialidade_id', 'especialidade.id')
                    ->whereNotNull('item.especialidade_id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                    ->whereIn('solicitacao.status_id', $params->status)
                    ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                        ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                    )
                )
                ->selectRaw("
                    especialidade.id,
                    ocupacao.codigo,
                    especialidade.nome
                ")
                ->orderByRaw("especialidade.nome")
                ->get()
                ->map(fn ($especialidade) => [
                    'id' => $especialidade->id,
                    'descricao' => "{$especialidade->codigo} - {$especialidade->nome}",
                ]);
        }

        $ids = $especialidades->pluck('id')->all();

        return ['form' => $especialidades, 'model' => $ids];
    }

    private static function getPrioridades($params)
    {
        $prioridades = collect();

        if (!empty($params->exames) || !empty($params->procedimentos_cirurgicos) || !empty($params->especialidades)) {

            $prioridades = DB::table('regulacao_solicitacao_prioridade as prioridade')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao as solicitacao')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->leftJoin(
                        'regulacao_parametrizacao_prestador_interno as prestador_interno',
                        'prestador_interno.id',
                        'solicitacao.prestador_interno_id'
                    )
                    ->leftJoin(
                        'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                        'infraestrutura_prestadora_interna.id',
                        'prestador_interno.infraestrutura_id'
                    )
                    ->whereColumn('solicitacao.prioridade_id', 'prioridade.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                    ->whereIn('solicitacao.status_id', $params->status)
                    ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                        ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                    )
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao_item as item')
                        ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
                        ->leftJoin(
                            'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                            'procedimento_cirurgico.id',
                            'item.procedimento_cirurgico_id'
                        )
                        ->whereColumn('item.solicitacao_id', 'solicitacao.id')
                        ->where(fn ($q) => $q
                            ->where(fn ($q) => $q
                                ->where(fn ($q) => $q
                                    ->whereIn('exame.grupo_tipo_id', $params->grupos)
                                    ->orWhereIn('procedimento_cirurgico.grupo_exame_id', $params->grupos)
                                )
                                ->where(fn ($q) => $q
                                    ->whereIn('item.exame_id', $params->exames)
                                    ->orWhereIn('item.procedimento_cirurgico_id', $params->procedimentos_cirurgicos)
                                )
                            )
                            ->orWhereIn('item.especialidade_id', $params->especialidades)
                        )
                    )
                )
                ->selectRaw("
                    prioridade.id,
                    prioridade.nome
                ")
                ->orderBy('prioridade.nome')
                ->get();
        }

        return ['form' => $prioridades, 'model' => $prioridades->pluck('id')];
    }

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

        return DB::table('sigtap.cid as cid')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('regulacao_solicitacao as solicitacao')
                ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                    ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                    ->where('movimentacao.id', fn ($q) => $q
                        ->select('movimentacao2.id')
                        ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                        ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                        ->orderByDesc('movimentacao2.id')
                        ->limit(1)
                    )
                )
                ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                ->join(
                    'regulacao_parametrizacao_regulador as regulador',
                    'regulador.id',
                    'solicitacao.regulador_id'
                )
                ->join(
                    'cadastro_infraestrutura as infraestrutura_reguladora',
                    'infraestrutura_reguladora.id',
                    'regulador.infraestrutura_id'
                )
                ->join(
                    'cadastro_infraestrutura as infraestrutura_solicitante',
                    'infraestrutura_solicitante.id',
                    'solicitacao.infraestrutura_solicitante_id'
                )
                ->leftJoin(
                    'regulacao_parametrizacao_prestador_interno as prestador_interno',
                    'prestador_interno.id',
                    'solicitacao.prestador_interno_id'
                )
                ->leftJoin(
                    'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                    'infraestrutura_prestadora_interna.id',
                    'prestador_interno.infraestrutura_id'
                )
                ->whereColumn('solicitacao.cid_id', 'cid.id')
                ->whereNotNull('solicitacao.cid_id')
                ->whereNotNull('solicitacao.confirmado_em')
                ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                ->when($params->nenhum_prestador, fn ($q) => $q
                    ->whereNull('solicitacao.prestador_interno_id')
                    ->whereNull('solicitacao.prestador_externo_id')
                )
                ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                ->whereIn('solicitacao.status_id', $params->status)
                ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                    ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                )
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao_item as item')
                    ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
                    ->leftJoin(
                        'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                        'procedimento_cirurgico.id',
                        'item.procedimento_cirurgico_id'
                    )
                    ->whereColumn('item.solicitacao_id', 'solicitacao.id')
                    ->where(fn ($q) => $q
                        ->where(fn ($q) => $q
                            ->where(fn ($q) => $q
                                ->whereIn('exame.grupo_tipo_id', $params->grupos)
                                ->orWhereIn('procedimento_cirurgico.grupo_exame_id', $params->grupos)
                            )
                            ->where(fn ($q) => $q
                                ->whereIn('item.exame_id', $params->exames)
                                ->orWhereIn('item.procedimento_cirurgico_id', $params->procedimentos_cirurgicos)
                            )
                        )
                        ->orWhereIn('item.especialidade_id', $params->especialidades)
                    )
                )
                ->whereIn('solicitacao.prioridade_id', $params->prioridades)
            )
            ->selectRaw("
                cid.id,
                cid.codigo,
                cid.nome
            ");
    }

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

        return DB::table('geral_ciap as ciap')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('regulacao_solicitacao as solicitacao')
                ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                    ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                    ->where('movimentacao.id', fn ($q) => $q
                        ->select('movimentacao2.id')
                        ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                        ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                        ->orderByDesc('movimentacao2.id')
                        ->limit(1)
                    )
                )
                ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                ->join(
                    'regulacao_parametrizacao_regulador as regulador',
                    'regulador.id',
                    'solicitacao.regulador_id'
                )
                ->join(
                    'cadastro_infraestrutura as infraestrutura_reguladora',
                    'infraestrutura_reguladora.id',
                    'regulador.infraestrutura_id'
                )
                ->join(
                    'cadastro_infraestrutura as infraestrutura_solicitante',
                    'infraestrutura_solicitante.id',
                    'solicitacao.infraestrutura_solicitante_id'
                )
                ->leftJoin(
                    'regulacao_parametrizacao_prestador_interno as prestador_interno',
                    'prestador_interno.id',
                    'solicitacao.prestador_interno_id'
                )
                ->leftJoin(
                    'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                    'infraestrutura_prestadora_interna.id',
                    'prestador_interno.infraestrutura_id'
                )
                ->whereColumn('solicitacao.ciap_id', 'ciap.id')
                ->whereNotNull('solicitacao.ciap_id')
                ->whereNotNull('solicitacao.confirmado_em')
                ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                ->when($params->nenhum_prestador, fn ($q) => $q
                    ->whereNull('solicitacao.prestador_interno_id')
                    ->whereNull('solicitacao.prestador_externo_id')
                )
                ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                ->whereIn('solicitacao.status_id', $params->status)
                ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                    ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                )
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('regulacao_solicitacao_item as item')
                    ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
                    ->leftJoin(
                        'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                        'procedimento_cirurgico.id',
                        'item.procedimento_cirurgico_id'
                    )
                    ->whereColumn('item.solicitacao_id', 'solicitacao.id')
                    ->where(fn ($q) => $q
                        ->where(fn ($q) => $q
                            ->where(fn ($q) => $q
                                ->whereIn('exame.grupo_tipo_id', $params->grupos)
                                ->orWhereIn('procedimento_cirurgico.grupo_exame_id', $params->grupos)
                            )
                            ->where(fn ($q) => $q
                                ->whereIn('item.exame_id', $params->exames)
                                ->orWhereIn('item.procedimento_cirurgico_id', $params->procedimentos_cirurgicos)
                            )
                        )
                        ->orWhereIn('item.especialidade_id', $params->especialidades)
                    )
                )
                ->whereIn('solicitacao.prioridade_id', $params->prioridades)
                ->when($params->cid_id, fn ($q, $id) => $q->where('solicitacao.cid_id', $id))
            )
            ->selectRaw("
                ciap.id,
                ciap.codigo,
                ciap.descricao
            ");
    }

    private static function getSexos($params)
    {
        $sexos = collect();

        if (!empty($params->prioridades)) {

            $sexos = DB::table('cadastro_sexo as sexo')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('cadastro_cidadao as cidadao')
                    ->join('cadastro_paciente as paciente', 'paciente.cidadao_id', 'cidadao.id')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.paciente_id', 'paciente.id')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->leftJoin(
                        'regulacao_parametrizacao_prestador_interno as prestador_interno',
                        'prestador_interno.id',
                        'solicitacao.prestador_interno_id'
                    )
                    ->leftJoin(
                        'cadastro_infraestrutura as infraestrutura_prestadora_interna',
                        'infraestrutura_prestadora_interna.id',
                        'prestador_interno.infraestrutura_id'
                    )
                    ->whereColumn('cidadao.sexo_id', 'sexo.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                    ->whereIn('solicitacao.status_id', $params->status)
                    ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                        ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                    )
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao_item as item')
                        ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
                        ->leftJoin(
                            'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                            'procedimento_cirurgico.id',
                            'item.procedimento_cirurgico_id'
                        )
                        ->whereColumn('item.solicitacao_id', 'solicitacao.id')
                        ->where(fn ($q) => $q
                            ->where(fn ($q) => $q
                                ->where(fn ($q) => $q
                                    ->whereIn('exame.grupo_tipo_id', $params->grupos)
                                    ->orWhereIn('procedimento_cirurgico.grupo_exame_id', $params->grupos)
                                )
                                ->where(fn ($q) => $q
                                    ->whereIn('item.exame_id', $params->exames)
                                    ->orWhereIn('item.procedimento_cirurgico_id', $params->procedimentos_cirurgicos)
                                )
                            )
                            ->orWhereIn('item.especialidade_id', $params->especialidades)
                        )
                    )
                    ->whereIn('solicitacao.prioridade_id', $params->prioridades)
                    ->when($params->cid_id, fn ($q, $id) => $q->where('solicitacao.cid_id', $id))
                    ->when($params->ciap_id, fn ($q, $id) => $q->where('solicitacao.ciap_id', $id))
                )
                ->selectRaw("
                    sexo.id,
                    sexo.descricao
                ")
                ->orderBy('sexo.descricao')
                ->get();
        }

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

    private static function getOcis($params)
    {
        $ocis = collect();

        if (!empty($params->prioridades)) {

            $ocis = DB::table('cadastro_oci AS oci')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('ambulatorio_acompanhamento_oci as acompanhamento_oci')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.acompanhamento_oci_id', 'acompanhamento_oci.id')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->whereColumn('acompanhamento_oci.oci_id', 'oci.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                    ->whereIn('solicitacao.status_id', $params->status)
                    ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                        ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                    )
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao_item as item')
                        ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
                        ->leftJoin(
                            'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                            'procedimento_cirurgico.id',
                            'item.procedimento_cirurgico_id'
                        )
                        ->whereColumn('item.solicitacao_id', 'solicitacao.id')
                        ->where(fn ($q) => $q
                            ->where(fn ($q) => $q
                                ->where(fn ($q) => $q
                                    ->whereIn('exame.grupo_tipo_id', $params->grupos)
                                    ->orWhereIn('procedimento_cirurgico.grupo_exame_id', $params->grupos)
                                )
                                ->where(fn ($q) => $q
                                    ->whereIn('item.exame_id', $params->exames)
                                    ->orWhereIn('item.procedimento_cirurgico_id', $params->procedimentos_cirurgicos)
                                )
                            )
                            ->orWhereIn('item.especialidade_id', $params->especialidades)
                        )
                    )
                    ->whereIn('solicitacao.prioridade_id', $params->prioridades)
                    ->when($params->cid_id, fn ($q, $id) => $q->where('solicitacao.cid_id', $id))
                    ->when($params->ciap_id, fn ($q, $id) => $q->where('solicitacao.ciap_id', $id))
                    ->when($params->sexo_id, fn ($q, $id) => $q->where('paciente_cidadao.sexo_id', $id))
                )
                ->select(
                    'oci.id',
                    'oci.nome'
                )
                ->orderBy('oci.nome')
                ->get();
        }

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

    private static function getEtapasClinicas($params)
    {
        $etapasClinicas = collect();

        if (!empty($params->prioridades)) {

            $etapasClinicas = DB::table('cadastro_etapa_clinica as etapa_clinica')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('ambulatorio_acompanhamento_oci as acompanhamento_oci')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.acompanhamento_oci_id', 'acompanhamento_oci.id')
                    ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                        ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                        ->where('movimentacao.id', fn ($q) => $q
                            ->select('movimentacao2.id')
                            ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                            ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                            ->orderByDesc('movimentacao2.id')
                            ->limit(1)
                        )
                    )
                    ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
                    ->join('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
                    ->join(
                        'regulacao_parametrizacao_regulador as regulador',
                        'regulador.id',
                        'solicitacao.regulador_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_reguladora',
                        'infraestrutura_reguladora.id',
                        'regulador.infraestrutura_id'
                    )
                    ->join(
                        'cadastro_infraestrutura as infraestrutura_solicitante',
                        'infraestrutura_solicitante.id',
                        'solicitacao.infraestrutura_solicitante_id'
                    )
                    ->whereColumn('acompanhamento_oci.etapa_clinica_atual_id', 'etapa_clinica.id')
                    ->whereNotNull('solicitacao.confirmado_em')
                    ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
                    ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
                    ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
                    ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
                    ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
                    ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
                    ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
                    ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
                    ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
                    ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
                    ->when($params->nenhum_prestador, fn ($q) => $q
                        ->whereNull('solicitacao.prestador_interno_id')
                        ->whereNull('solicitacao.prestador_externo_id')
                    )
                    ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
                    ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
                    ->whereIn('solicitacao.status_id', $params->status)
                    ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                        ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
                    )
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao_item as item')
                        ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
                        ->leftJoin(
                            'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                            'procedimento_cirurgico.id',
                            'item.procedimento_cirurgico_id'
                        )
                        ->whereColumn('item.solicitacao_id', 'solicitacao.id')
                        ->where(fn ($q) => $q
                            ->where(fn ($q) => $q
                                ->where(fn ($q) => $q
                                    ->whereIn('exame.grupo_tipo_id', $params->grupos)
                                    ->orWhereIn('procedimento_cirurgico.grupo_exame_id', $params->grupos)
                                )
                                ->where(fn ($q) => $q
                                    ->whereIn('item.exame_id', $params->exames)
                                    ->orWhereIn('item.procedimento_cirurgico_id', $params->procedimentos_cirurgicos)
                                )
                            )
                            ->orWhereIn('item.especialidade_id', $params->especialidades)
                        )
                    )
                    ->whereIn('solicitacao.prioridade_id', $params->prioridades)
                    ->when($params->cid_id, fn ($q, $id) => $q->where('solicitacao.cid_id', $id))
                    ->when($params->ciap_id, fn ($q, $id) => $q->where('solicitacao.ciap_id', $id))
                    ->when($params->sexo_id, fn ($q, $id) => $q->where('paciente_cidadao.sexo_id', $id))
                    ->when($params->oci_id, fn ($q, $id) => $q->where('acompanhamento_oci.oci_id', $id))
                )
                ->select(
                    'etapa_clinica.id',
                    'etapa_clinica.nome'
                )
                ->orderBy('etapa_clinica.nome')
                ->get();
        }


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

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

        $solicitacoes = DB::table('regulacao_solicitacao as solicitacao')
            ->join('regulacao_solicitacao_movimentacao as movimentacao', fn ($j) => $j
                ->on('movimentacao.solicitacao_id', 'solicitacao.id')
                ->where('movimentacao.id', fn ($q) => $q
                    ->select('movimentacao2.id')
                    ->from('regulacao_solicitacao_movimentacao as movimentacao2')
                    ->whereColumn('movimentacao2.solicitacao_id', 'solicitacao.id')
                    ->orderByDesc('movimentacao2.id')
                    ->limit(1)
                )
            )
            ->join('cadastro_paciente as paciente', 'paciente.id', 'solicitacao.paciente_id')
            ->join('cadastro_cidadao as paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
            ->join('regulacao_status as status', 'status.id', 'solicitacao.status_id')
            ->join('regulacao_solicitacao_prioridade as prioridade', 'prioridade.id', 'solicitacao.prioridade_id')
            ->join(
                'regulacao_parametrizacao_regulador as regulador',
                'regulador.id',
                'solicitacao.regulador_id'
            )
            ->join(
                'cadastro_infraestrutura as infraestrutura_reguladora',
                'infraestrutura_reguladora.id',
                'regulador.infraestrutura_id'
            )
            ->join(
                'cadastro_infraestrutura as infraestrutura_solicitante',
                'infraestrutura_solicitante.id',
                'solicitacao.infraestrutura_solicitante_id'
            )
            ->join(
                'cadastro_unidade as unidade_solicitante',
                'unidade_solicitante.id',
                'infraestrutura_solicitante.unidade_id'
            )
            ->join(
                'cadastro_usuario as usuario_solicitante',
                'usuario_solicitante.id',
                'solicitacao.usuario_solicitante_id'
            )
            ->join(
                'cadastro_cidadao as usuario_cidadao_solicitante',
                'usuario_cidadao_solicitante.id',
                'usuario_solicitante.cidadao_id'
            )
            ->join(
                'cadastro_lotacao as lotacao_solicitacao',
                'lotacao_solicitacao.id',
                'solicitacao.created_lotacao_id'
            )
            ->join(
                'cadastro_usuario as usuario_solicitacao',
                'usuario_solicitacao.id',
                'lotacao_solicitacao.usuario_id'
            )
            ->join(
                'cadastro_cidadao as usuario_cidadao_solicitacao',
                'usuario_cidadao_solicitacao.id',
                'usuario_solicitacao.cidadao_id'
            )
            ->join('regulacao_solicitacao_item as item', 'item.solicitacao_id', 'solicitacao.id')
            ->leftJoin('sigtap.cid as cid', 'cid.id', 'solicitacao.cid_id')
            ->leftJoin('geral_ciap as ciap', 'ciap.id', 'solicitacao.ciap_id')
            ->leftJoin('cadastro_sexo as paciente_sexo', 'paciente_sexo.id', 'paciente_cidadao.sexo_id')
            ->leftJoin(
                'regulacao_parametrizacao_prestador_interno as prestador_interno',
                'prestador_interno.id',
                'solicitacao.prestador_interno_id'
            )
            ->leftJoin(
                'cadastro_infraestrutura as prestador_interno_infraestrutura',
                'prestador_interno_infraestrutura.id',
                'prestador_interno.infraestrutura_id'
            )
            ->leftJoin(
                'cadastro_unidade as prestador_interno_unidade',
                'prestador_interno_unidade.id',
                'prestador_interno_infraestrutura.unidade_id'
            )
            ->leftJoin(
                'regulacao_parametrizacao_prestador_externo as prestador_externo',
                'prestador_externo.id',
                'solicitacao.prestador_externo_id'
            )
            ->leftJoin(
                'transporte_paciente_destino as prestador_externo_destino',
                'prestador_externo_destino.id',
                'prestador_externo.destino_id'
            )
            ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
            ->leftJoin(
                'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                'procedimento_cirurgico.id',
                'item.procedimento_cirurgico_id'
            )
            ->leftJoin('cadastro_especialidade as especialidade', 'especialidade.id', 'item.especialidade_id')
            ->leftJoin('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
            ->leftJoin('ambulatorio_atendimento_soap as soap', 'soap.id', 'solicitacao.soap_id')
            ->leftJoin(
                'ambulatorio_acompanhamento_oci as acompanhamento_oci',
                'acompanhamento_oci.id',
                'solicitacao.acompanhamento_oci_id'
            )
            ->whereNotNull('solicitacao.confirmado_em')
            ->when($params->periodo['start'], fn ($q, $start) => $q->where('solicitacao.data', '>=', $start))
            ->when($params->periodo['end'], fn ($q, $end) => $q->where('solicitacao.data', '<=', $end))
            ->when($params->periodo_movimentacao['start'], fn ($q, $start) => $q->where('movimentacao.movimentado_em', '>=', $start))
            ->when($params->periodo_movimentacao['end'], fn ($q, $end) => $q->where('movimentacao.movimentado_em', '<=', $end))
            ->when($params->paciente_id, fn ($q, $id) => $q->where('solicitacao.paciente_id', $id))
            ->when($params->idade_de, fn ($q, $idadeDe) => $q
                ->whereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, CURDATE()) >= ?", [$idadeDe])
            )
            ->when($params->idade_ate, fn ($q, $idadeAte) => $q
                ->whereRaw("TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, CURDATE()) <= ?", [$idadeAte])
            )
            ->when($params->unidade_reguladora_id, fn ($q, $id) => $q->where('infraestrutura_reguladora.unidade_id', $id))
            ->when($params->regulador_id, fn ($q, $id) => $q->where('solicitacao.regulador_id', $id))
            ->when($params->unidade_solicitante_id, fn ($q, $id) => $q->where('infraestrutura_solicitante.unidade_id', $id))
            ->when($params->infraestrutura_solicitante_id, fn ($q, $id) => $q->where('solicitacao.infraestrutura_solicitante_id', $id))
            ->when($params->unidade_referencia_id, fn ($q, $id) => $q->where('paciente.unidade_id', $id))
            ->when($params->usuario_solicitante_id, fn ($q, $id) => $q->where('solicitacao.usuario_solicitante_id', $id))
            ->when($params->nenhum_prestador, fn ($q) => $q
                ->whereNull('solicitacao.prestador_interno_id')
                ->whereNull('solicitacao.prestador_externo_id')
            )
            ->when($params->prestador_interno_id, fn ($q, $id) => $q->where('solicitacao.prestador_interno_id', $id))
            ->when($params->prestador_externo_id, fn ($q, $id) => $q->where('solicitacao.prestador_externo_id', $id))
            ->whereIn('solicitacao.status_id', $params->status)
            ->when($params->opcao_retirada_protocolo_agendamento_id, fn ($q, $id) => $q
                ->where('solicitacao.opcao_retirada_protocolo_agendamento_id', $id)
            )
            ->where(fn ($q) => $q
                ->where(fn ($q) => $q
                    ->where(fn ($q) => $q
                        ->whereIn('exame.grupo_tipo_id', $params->grupos)
                        ->orWhereIn('procedimento_cirurgico.grupo_exame_id', $params->grupos)
                    )
                    ->where(fn ($q) => $q
                        ->whereIn('item.exame_id', $params->exames)
                        ->orWhereIn('item.procedimento_cirurgico_id', $params->procedimentos_cirurgicos)
                    )
                )
                ->orWhereIn('item.especialidade_id', $params->especialidades)
            )
            ->whereIn('solicitacao.prioridade_id', $params->prioridades)
            ->when($params->cid_id, fn ($q, $id) => $q->where('solicitacao.cid_id', $id))
            ->when($params->ciap_id, fn ($q, $id) => $q->where('solicitacao.ciap_id', $id))
            ->when($params->sexo_id, fn ($q, $id) => $q->where('paciente_cidadao.sexo_id', $id))
            ->when($params->oci_id, fn ($q, $id) => $q->where('acompanhamento_oci.oci_id', $id))
            ->when($params->etapa_clinica_id, fn ($q, $id) => $q->where('acompanhamento_oci.etapa_clinica_atual_id', $id))
            ->selectRaw("
                solicitacao.id,
                DATE_FORMAT(solicitacao.data, '%d/%m/%Y') as data,
                DATE_FORMAT(solicitacao.data_desejada, '%d/%m/%Y') as data_desejada,
                DATE_FORMAT(movimentacao.movimentado_em, '%d/%m/%Y') as data_movimentacao,
                " . (isset($params->regulador_id)
                    ? "IF(solicitacao.posicao_regulador IS NULL, NULL, LPAD(solicitacao.posicao_regulador, 6, '0'))"
                    : "IF(solicitacao.posicao_municipal IS NULL, NULL, LPAD(solicitacao.posicao_municipal, 6, '0'))"
                ) . " as posicao,
                prioridade.nome as prioridade_nome,
                CONCAT(
                    paciente_cidadao.nome,
                    IF(paciente_cidadao.nome_social IS NULL,
                        '',
                        CONCAT(' (', paciente_cidadao.nome_social, ')')
                    )
                ) as paciente_nome,
                paciente_cidadao.data_nascimento as paciente_data_nascimento,
                paciente.protocolo_cross as paciente_protocolo_cross,
                CONCAT(TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, CURDATE()), ' anos') as paciente_idade,
                paciente_sexo.descricao as sexo_descricao,
                LPAD(paciente.prontuario, 7, '0') as prontuario,
                IF(EXISTS(
                    SELECT  1
                    FROM    cadastro_obito as obito
                    WHERE   obito.cidadao_id = paciente_cidadao.id
                    AND     obito.deleted_at IS NULL
                ), 1, 0) as paciente_em_obito,
                unidade_solicitante.nome_fantasia as unidade_solicitante_nome_fantasia,
                COALESCE(infraestrutura_solicitante.nome, unidade_solicitante.nome_fantasia) as infraestrutura_solicitante_nome,
                usuario_cidadao_solicitante.nome as usuario_solicitante_nome,
                usuario_cidadao_solicitacao.nome as usuario_registrou_solicitacao_nome,
                cid.id as cid_id,
                cid.codigo as cid_codigo,
                cid.nome as cid_nome,
                ciap.codigo as ciap_codigo,
                ciap.descricao as ciap_descricao,
                solicitacao.hipotese_diagnostica_justificativa,
                status.tipo_id as status_tipo_id,
                status.nome as status_nome,
                TIMESTAMPDIFF(
                    DAY,
                    (
                        SELECT      STR_TO_DATE(CONCAT(solicitacao_historico.data, ' 00:00:00'), '%Y-%m-%d %H:%i:%s')
                        FROM        regulacao_solicitacao_historico as solicitacao_historico
                        JOIN        regulacao_status solicitacao_historico_status
                        ON          solicitacao_historico_status.id = solicitacao_historico.status_id
                        WHERE       solicitacao_historico.solicitacao_id = solicitacao.id
                        AND         solicitacao_historico_status.tipo_id = " . StatusTipo::SOLICITADO . "
                        ORDER BY    solicitacao_historico.created_at
                        LIMIT       1
                    ),
                    COALESCE((
                        SELECT      solicitacao_historico.created_at
                        FROM        regulacao_solicitacao_historico as solicitacao_historico
                        JOIN        regulacao_status solicitacao_historico_status
                        ON          solicitacao_historico_status.id = solicitacao_historico.status_id
                        WHERE       solicitacao_historico.solicitacao_id = solicitacao.id
                        AND         solicitacao_historico_status.tipo_id IN (
                            " . StatusTipo::AGENDADO . ",
                            " . StatusTipo::REAGENDADO . "
                        )
                        ORDER BY    solicitacao_historico.created_at
                        LIMIT       1
                    ), CURRENT_TIMESTAMP)
                ) as tempo_espera,
                (
                    CASE
                        WHEN solicitacao.prestador_interno_id IS NOT NULL
                            THEN IF (prestador_interno_infraestrutura.nome IS NULL,
                                prestador_interno_unidade.nome_fantasia,
                                CONCAT(prestador_interno_unidade.nome_fantasia, ' (', prestador_interno_infraestrutura.nome, ')')
                            )
                        WHEN solicitacao.prestador_externo_id IS NOT NULL
                            THEN prestador_externo_destino.descricao_destino
                        ELSE NULL
                    END
                ) as prestador_descricao,
                CONCAT(
                    DATE_FORMAT(solicitacao.data_agendada, '%d/%m/%Y'),
                    ' às ',
                    DATE_FORMAT(solicitacao.hora_agendada, '%H:%i')
                ) as agendamento,
                IF(status.tipo_id IN (" . self::getStatusTiposQueFinalizamSolicitacao()->join(', ') . "), 0, 1) as allow_update,
                IF(status.tipo_id IN (" . self::getStatusTipoDeAgendamento()->join(', ') . "), 1, 0) as allow_update_protocolo_agendamento,
                soap.atendimento_id as ambulatorio_atendimento_id,
                GROUP_CONCAT((
                    CASE
                        WHEN item.exame_id IS NOT NULL
                            THEN IF (exame.codigo IS NULL OR exame.codigo = '',
                                exame.nome,
                                CONCAT(
                                    CONCAT(
                                        SUBSTR(exame.codigo, 1, 2),
                                        '.',
                                        SUBSTR(exame.codigo, 3, 2),
                                        '.',
                                        SUBSTR(exame.codigo, 5, 2),
                                        '.',
                                        SUBSTR(exame.codigo, 7, 3),
                                        '-',
                                        SUBSTR(exame.codigo, 10, 1)
                                    ),
                                    ' - ',
                                    exame.nome
                                )
                            )
                        WHEN item.procedimento_cirurgico_id IS NOT NULL
                            THEN CONCAT(
                                CONCAT(
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 1, 2),
                                    '.',
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 3, 2),
                                    '.',
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 5, 2),
                                    '.',
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 7, 3),
                                    '-',
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 10, 1)
                                ),
                                ' - ',
                                procedimento_cirurgico.nome
                            )
                        WHEN item.especialidade_id IS NOT NULL
                            THEN CONCAT(ocupacao.codigo, ' - ', especialidade.nome)
                    END
                ) SEPARATOR '#') AS itens,
                (status.tipo_id = " . StatusTipo::AGENDADO . ") as is_agendado,
                (solicitacao.prioridade_id = " . SolicitacaoPrioridade::URGENCIA . ") as urgente,
                solicitacao.prestador_externo_id,
                solicitacao.soap_id,
                IF(status.tipo_id = " . StatusTipo::DEVOLVIDO . ", solicitacao.justificativa_devolucao, NULL) as justificativa_devolucao,
                IF(solicitacao.acompanhamento_oci_id IS NULL, 0, 1) as has_oci,
                DATE_FORMAT(LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH)), '%d/%m/%Y') AS data_vencimento_oci,
                TIMESTAMPDIFF(DAY,
                    CURRENT_DATE,
                    LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))
                ) AS dias_restantes_oci,
                IF(CURRENT_DATE <= LAST_DAY(DATE_ADD(solicitacao.data, INTERVAL 1 MONTH)), 1, 0) AS dentro_validade_inserir_oci,
                IF(acompanhamento_oci.etapa_clinica_atual_id = " . EtapaClinica::ALTA . ", 1, 0) AS has_alta_oci,
                (
                    SELECT      GROUP_CONCAT(cct.numero SEPARATOR '#')
                    FROM        cadastro_cidadao_telefone cct
                    WHERE       cct.cidadao_id = paciente_cidadao.id
                    AND         cct.deleted_at IS NULL
                ) as telefones
            ")
            ->groupByRaw("
                solicitacao.id,
                DATE_FORMAT(solicitacao.data, '%d/%m/%Y'),
                DATE_FORMAT(solicitacao.data_desejada, '%d/%m/%Y'),
                DATE_FORMAT(movimentacao.movimentado_em, '%d/%m/%Y'),
                posicao,
                prioridade.nome,
                paciente_cidadao.data_nascimento,
                paciente_idade,
                paciente_protocolo_cross,
                paciente_nome,
                paciente_sexo.descricao,
                LPAD(paciente.prontuario, 7, '0'),
                paciente_em_obito,
                unidade_solicitante.nome_fantasia,
                COALESCE(infraestrutura_solicitante.nome, unidade_solicitante.nome_fantasia),
                usuario_cidadao_solicitante.nome,
                usuario_cidadao_solicitacao.nome,
                cid.id,
                cid.codigo,
                cid.nome,
                ciap.codigo,
                ciap.descricao,
                solicitacao.hipotese_diagnostica_justificativa,
                status.tipo_id,
                status.nome,
                tempo_espera,
                prestador_descricao,
                agendamento,
                allow_update,
                allow_update_protocolo_agendamento,
                soap.atendimento_id,
                is_agendado,
                urgente,
                solicitacao.prestador_externo_id,
                solicitacao.soap_id,
                IF(status.tipo_id = " . StatusTipo::DEVOLVIDO . ", solicitacao.justificativa_devolucao, NULL),
                IF(solicitacao.acompanhamento_oci_id IS NULL, 0, 1),
                data_vencimento_oci,
                dias_restantes_oci,
                dentro_validade_inserir_oci,
                has_alta_oci,
                telefones
            ");

        return $solicitacoes;
    }

    public static function getTentativasContato()
    {
        return DB::table('regulacao_solicitacao_tentativa_contato as tentativa_contato')
            ->join('cadastro_usuario as usuario', 'usuario.id', 'tentativa_contato.usuario_id')
            ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->where('solicitacao_id', request()->solicitacao_id)
            ->selectRaw("
                tentativa_contato.id,
                tentativa_contato.data,
                cidadao.nome as usuario_nome,
                tentativa_contato.detalhes
            ")
            ->get();
    }

    public static function getImpressoes()
    {
        $solicitacao = Solicitacao::findOrFail(request()->solicitacao_id);
        $impressoes = collect();

        $impressoes->push([
            'value' => 'solicitacao',
            'text' => 'Protocolo de solicitação',
        ]);

        if (self::hasPreparos($solicitacao)) {

            $impressoes->push([
                'value' => 'preparo',
                'text' => 'Preparos',
            ]);
        }

        if (!is_null($solicitacao->soap_id) && self::isSupervisor()) {

            if (self::hasFichaSadt($solicitacao)) {

                $impressoes->push([
                    'value' => 'fichaRequisicaoServicoAuxiliarDiagnoseTerapia',
                    'text' => 'Ficha de requisição de serviços auxiliares de diagnose e terapia (SADT)',
                ]);
            }

            if (self::hasFichaSadat($solicitacao)) {

                $impressoes->push([
                    'value' => 'servicoAnaliseDiagnosticoTerapiaSolicitacaoExame',
                    'text' => 'Serviço de análises, diagnósticos e terapia, solicitação de exames (SADAT)',
                ]);
            }

            if (self::hasLaudoSolicitacaoAutorizacaoProcedimentoAmbulatorial($solicitacao)) {

                $impressoes->push([
                    'value' => 'laudoSolicitacaoAutorizacaoProcedimentoAmbulatorial',
                    'text' => 'Laudo para solicitacao/autorizacao de procedimento ambulatorial',
                ]);
            }

            if (self::hasEncaminhamento($solicitacao)) {

                $impressoes->push([
                    'value' => 'encaminhamento',
                    'text' => 'Encaminhamento',
                ]);
            }
        }

        if ($solicitacao->status->tipo->id === StatusTipo::AGENDADO || $solicitacao->status->tipo->id === StatusTipo::REAGENDADO) {

            if (self::hasExame($solicitacao) === TipoExame::LABORATORIAL) {

                $impressoes->push([
                    'value' => 'protocoloAgendamentoExameLaboratorial',
                    'text' => 'Protocolo de agendamento de exame laboratorial',
                ]);
            } else if (self::hasExame($solicitacao) === TipoExame::IMAGEM) {

                $impressoes->push([
                    'value' => 'protocoloAgendamentoExameImagem',
                    'text' => 'Protocolo de agendamento de exame de imagem',
                ]);
            } else if (self::hasProcedimentoCirurgico($solicitacao) && !$solicitacao->prestador_externo_id) {

                $impressoes->push([
                    'value' => 'protocoloAgendamentoProcedimentoCirurgico',
                    'text' => 'Protocolo de agendamento de procedimento cirúrgico',
                ]);
            } else if (self::hasEspecialidade($solicitacao)) {

                $impressoes->push([
                    'value' => 'protocoloAgendamentoEspecialidade',
                    'text' => 'Protocolo de agendamento de consulta',
                ]);
            }
        }

        return $impressoes->sortBy('text')->values();
    }

    private static function hasExame($solicitacao)
    {

        if ($solicitacao->itens()->whereNotNull('exame_id')->exists()) {

            return $solicitacao->itens()->first('exame_id')->exame->tipo_id;
        }

        return false;
    }

    private static function hasProcedimentoCirurgico($solicitacao)
    {
        return $solicitacao->itens()->whereNotNull('procedimento_cirurgico_id')->exists();
    }

    private static function hasEspecialidade($solicitacao)
    {
        return $solicitacao->itens()->whereNotNull('especialidade_id')->exists();
    }

    private static function hasFichaSadt($solicitacao)
    {
        $examesIds = $solicitacao->itens()->pluck('exame_id');

        if ($examesIds->isEmpty()) {

            return false;
        }

        return $solicitacao->soap->solicitacoesExames()
            ->whereHas('itens.exame', fn ($q) => $q
                ->where('tipo_id', TipoExame::IMAGEM)
                ->whereIn('id', $examesIds)
            )
            ->exists();
    }

    private static function hasFichaSadat($solicitacao)
    {
        $examesIds = $solicitacao->itens()->pluck('exame_id');

        if ($examesIds->isEmpty()) {

            return false;
        }

        return $solicitacao->soap->solicitacoesExames()
            ->whereHas('itens.exame', fn ($q) => $q
                ->where('tipo_id', TipoExame::LABORATORIAL)
                ->whereIn('id', $examesIds)
            )
            ->exists();
    }

    private static function hasLaudoSolicitacaoAutorizacaoProcedimentoAmbulatorial($solicitacao)
    {
        $examesIds = $solicitacao->itens()->pluck('exame_id');

        if ($examesIds->isEmpty()) {

            return false;
        }

        return DB::table('ambulatorio_atendimento_soap_solicitacao_exame_item as solicitacao_exame_item')
            ->join(
                'ambulatorio_atendimento_soap_solicitacao_exame as solicitacao_exame',
                'solicitacao_exame.id',
                'solicitacao_exame_item.solicitacao_exame_id'
            )
            ->join('parametrizacao_exame as exame', 'exame.id', 'solicitacao_exame_item.exame_id')
            ->where('solicitacao_exame.soap_id', $solicitacao->soap_id)
            ->whereIn('solicitacao_exame_item.exame_id', $examesIds)
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('sigtap.procedimento as procedimento')
                ->where('procedimento.complexidade', Complexidade::ALTA_COMPLEXIDADE)
                ->whereColumn('procedimento.codigo', 'exame.codigo')
                ->orderByDesc('procedimento.competencia_id')
                ->limit(1)
            )
            ->exists();
    }

    private static function hasEncaminhamento($solicitacao)
    {
        $especialidadesId = $solicitacao->itens()->first('especialidade_id')->especialidade_id;

        if (is_null($especialidadesId)) {

            return false;
        }

        return $solicitacao->soap->encaminhamentos()
            ->where('servico_especializado_especialidade_id', $especialidadesId)
            ->exists();
    }

    private static function hasPreparos($solicitacao)
    {
        if (is_null($solicitacao->prestador_interno_id) && is_null($solicitacao->prestador_externo_id)) {

            return false;
        }

        $hasPreparo = false;
        $prestadorRelationName = is_null($solicitacao->prestador_interno_id) ? 'prestadorExterno' : 'prestadorInterno';

        $solicitacao->itens->each(function ($item) use ($solicitacao, &$hasPreparo, $prestadorRelationName) {

            $hasPreparoExame = fn () => !is_null($item->exame_id)
                && $solicitacao->{$prestadorRelationName}->exames()
                    ->where('id', $item->exame_id)
                    ->wherePivotNotNull('observacoes')
                    ->exists();

            $hasPreparoProcedimentoCirurgico = fn () => !is_null($item->procedimento_cirurgico_id)
                && $solicitacao->{$prestadorRelationName}->procedimentosCirurgicos()
                    ->where('id', $item->procedimento_cirurgico_id)
                    ->wherePivotNotNull('observacoes')
                    ->exists();

            $hasPreparoEspecialidade = fn () => !is_null($item->especialidade_id)
                && $solicitacao->{$prestadorRelationName}->especialidades()
                    ->where('id', $item->especialidade_id)
                    ->wherePivotNotNull('observacoes')
                    ->exists();

            if ($hasPreparoExame() || $hasPreparoProcedimentoCirurgico() || $hasPreparoEspecialidade()) {

                $hasPreparo = true;

                return true;
            }
        });

        return $hasPreparo;
    }

    public static function editProtocoloAgendamento($solicitacaoId)
    {
        $solicitacao = Solicitacao::findOrFail($solicitacaoId);

        return [
            'form' => [
                'opcoes_retirada_protocolo_agendamento' => ParametrizacaoOpcaoRetiradaProtocoloAgendamento::orderBy('nome')
                    ->get(['id', 'nome']),
                'paciente_nome' => $solicitacao->paciente->cidadao->nome,
            ],
            'model' => [
                'opcao_retirada_protocolo_agendamento_id' => $solicitacao->opcao_retirada_protocolo_agendamento_id,
                'nome_pessoa_retirada_protocolo_agendamento' => $solicitacao->nome_pessoa_retirada_protocolo_agendamento,
            ],
        ];
    }

    public static function updateProtocoloAgendamento($solicitacaoId)
    {
        self::validateProtocoloAgendamento();

        $solicitacao = Solicitacao::findOrFail($solicitacaoId);

        $solicitacao->update([
            'opcao_retirada_protocolo_agendamento_id' => request()->opcao_retirada_protocolo_agendamento_id,
            'nome_pessoa_retirada_protocolo_agendamento' => request()->nome_pessoa_retirada_protocolo_agendamento,
        ]);

        SolicitacaoService::saveHistorico($solicitacao);

        return $solicitacao->fresh();
    }

    private static function validateProtocoloAgendamento()
    {
        request()->validate([
            'opcao_retirada_protocolo_agendamento_id' => [
                'required',
                Rule::exists(ParametrizacaoOpcaoRetiradaProtocoloAgendamento::class, 'id'),
            ],
            'nome_pessoa_retirada_protocolo_agendamento' => [
                'nullable',
                Rule::requiredIf(fn () => request()
                    ->opcao_retirada_protocolo_agendamento_id === OpcaoRetiradaProtocoloAgendamento::RETIRADO),
                'string',
                'max:150',
            ],
        ]);
    }

    public static function createTentativaContato($solicitacaoId)
    {
        $solicitacao = Solicitacao::findOrFail($solicitacaoId);
        $usuarioLogado = self::getCurrentLotacao()->usuario;

        return [
            'additionals' => [
                'data_atual' => Carbon::today()->format('d/m/Y'),
            ],
            'form' => [
                'paciente' => [
                    'nome' => $solicitacao->paciente->cidadao->nome,
                    'idade' => $solicitacao->paciente->cidadao->idade_formatada,
                    'data_nascimento' => $solicitacao->paciente->cidadao->data_nascimento
                        ? (new Carbon($solicitacao->paciente->cidadao->data_nascimento))->format('d/m/Y')
                        : null,
                    'prontuario' => $solicitacao->paciente->prontuario,
                    'telefones' => $solicitacao->paciente->cidadao->telefones->map(fn ($telefone) => [
                        'id' => $telefone->id,
                        'numero' => MaskUtil::getPhoneMasked($telefone->numero),
                        'observacao' => $telefone->observacao ?? '',
                        'autoriza_sms' => $telefone->autoriza_sms,
                        'principal' => $telefone->principal,
                    ]),
                ],
            ],
            'model' => [
                'data' => Carbon::today()->format('d/m/Y'),
                'usuario' => [
                    'id' => $usuarioLogado->id,
                    'cidadao_nome' => $usuarioLogado->cidadao->nome,
                ],
                'detalhes' => null,
            ],
        ];
    }

    public static function storeTentativaContato()
    {
        self::validateStoreTentativaContato();

        $tentativaContato = new SolicitacaoTentativaContato();

        DB::transaction(function () use ($tentativaContato) {

            $tentativaContato->fill([
                'solicitacao_id' => request()->solicitacao_id,
                'data' => Carbon::createFromFormat('d/m/Y', request()->data),
                'usuario_id' => request()->usuario_id,
                'detalhes' => request()->detalhes,
            ]);

            $tentativaContato->save();

            SolicitacaoService::saveHistorico($tentativaContato->solicitacao);

            $cidadao = $tentativaContato->solicitacao->paciente->cidadao;

            CidadaoService::deleteTelefonesNotPresent($cidadao, request()->paciente['telefones']);
            CidadaoService::saveTelefones($cidadao, request()->paciente['telefones']);
        });

        return $tentativaContato;
    }

    private static function validateStoreTentativaContato()
    {
        return request()->validate([
            'solicitacao_id' => [
                'required',
                'integer',
                Rule::exists(Solicitacao::class, 'id'),
            ],
            'data' => [
                'required',
                'date_format:d/m/Y',
                'before_or_equal:' . Carbon::today()->format('d/m/Y'),
            ],
            'usuario_id' => [
                'required',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'detalhes' => [
                'nullable',
                'string',
                'max:500',
            ],
            'paciente.telefones' => [
                'array',
                'nullable',
                function ($attribute, $value, $fail) {

                    if (empty($value)) return;

                    $hasPrincipal = false;

                    foreach (($value ?? []) as $telefone) {

                        if (($telefone['principal'] ?? null) === true) {

                            if ($hasPrincipal) {

                                $fail('Somente um telefone pode ser marcado como principal');

                                break;
                            }
                            else {

                                $hasPrincipal = true;
                            }
                        }
                    }

                    if (!$hasPrincipal) {

                        $fail('Obrigatório marcar um telefone como principal.');
                    }
                },
            ],
            'paciente.telefones.*.id' => [
                'nullable',
                'integer',
            ],
            'paciente.telefones.*.numero' => [
                'required',
                'digits_between:10,11',
            ],
            'paciente.telefones.*.observacao' => [
                'nullable',
                'string',
                'max:50',
            ],
            'paciente.telefones.*.autoriza_sms' => [
                'required',
                'boolean',
            ],
            'paciente.telefones.*.principal' => [
                'required',
                'boolean',
            ],
        ]);
    }

    public static function createOci($solicitacaoId)
    {
        $solicitacao = Solicitacao::findOrFail($solicitacaoId);

        return [
            'form' => [
                'ocis' => self::getOcisCompativeis($solicitacao)
            ],
            'model' => [
                'oci_id' => null
            ],
        ];
    }

    public static function getOcisCompativeis($solicitacao)
    {
        $codigosExames = $solicitacao->itens
            ->map(fn ($i) => $i->exame->codigo)
            ->filter()
            ->values();

        $builder = DB::table('cadastro_oci AS oci')
            ->join('sigtap.procedimento AS procedimento', fn ($j) => $j
                ->on('procedimento.codigo', 'oci.procedimento_codigo')
                ->where('competencia_id', DB::table('sigtap.competencia')->max('id'))
            )
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('sigtap.procedimento_cid AS procedimento_cid')
                ->whereColumn('procedimento_cid.procedimento_id', 'procedimento.id')
                ->where('procedimento_cid.cid_id', $solicitacao->cid_id)
            )
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('sigtap.procedimento_ocupacao AS procedimento_ocupacao')
                ->whereColumn('procedimento_ocupacao.procedimento_id', 'procedimento.id')
                ->where('procedimento_ocupacao.ocupacao_id', $solicitacao->ocupacao_usuario_id)
            )
            ->whereNotExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_oci_etapa_clinica AS etapa_clinica')
                ->whereColumn('etapa_clinica.oci_id', 'oci.id')
                ->where('etapa_clinica.etapa_clinica_id', EtapaClinica::ENTRADA_ALTA)
            );

        $codigosExames->each(function ($codigo) use ($builder) {

            $builder->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_oci_procedimento_primario AS oci_procedimento_primario')
                ->whereColumn('oci_procedimento_primario.oci_id', 'oci.id')
                ->where('oci_procedimento_primario.procedimento_codigo', $codigo)
            );
        });

        $ocis = $builder
            ->select(
                'oci.id',
                'oci.nome',
                'oci.linha_cuidado',
            )
            ->orderBy('oci.nome')
            ->get();

        return $ocis;
    }

    public static function storeOci($solicitacaoId)
    {
        $solicitacao = Solicitacao::findOrFail($solicitacaoId);

        self::validateStoreOci();

        DB::transaction(function () use ($solicitacao) {

            $acompanhamentoOci = AcompanhamentoOci::create([
                'paciente_id' => $solicitacao->paciente_id,
                'ocupacao_id' => $solicitacao->ocupacao_usuario_id,
                'oci_id' => request()->oci_id,
                'iniciado_em' => $solicitacao->data,
                'iniciado_lotacao_id' => $solicitacao->lotaca_usuario_id,
                'etapa_clinica_atual_id' => EtapaClinica::RETORNO,
                'status_id' => AcompanhamentoOciStatus::EM_ANDAMENTO,
            ]);

            $acompanhamentoOci->etapasClinicasConcluidas()->create([
                'etapa_clinica_id' => EtapaClinica::ENTRADA,
                'regulacao_solicitacao_id' => $solicitacao->id,
            ]);

            $solicitacao->update(['acompanhamento_oci_id' => $acompanhamentoOci->id]);

            SolicitacaoService::saveHistorico($solicitacao);
        });

        return $solicitacao->fresh();
    }

    private static function validateStoreOci()
    {
        request()->validate([
            'oci_id' => [
                'required',
                'integer',
                Rule::exists(Oci::class, 'id')
            ]
        ]);
    }

    public static function editSolicitacao($solicitacaoId)
    {
        $isPosicaoPorRegulador = DataUtil::isStringTrue(request()->get('posicao_por_regulador', 'true'));

        $solicitacao = Solicitacao::findOrFail($solicitacaoId);
        $parametrizacao = Parametrizacao::first();
        $parametrizacaoAmbulatorio = AmbulatorioParametrizacaoAgendamento::first();
        $cadastroParametrizacao = CadastroParametrizacao::first();
        $solicitacaoFinalizada = self::getStatusTiposQueFinalizamSolicitacao()->contains($solicitacao->status->tipo_id);
        $iniciouAtendimento = self::iniciouAtendimento($solicitacao);

        $status = collect();
        $statusQuePrecisamSenhaSupervisor = collect();

        if (!$solicitacaoFinalizada && !$iniciouAtendimento) {

            $statusPara = self::getStatusPara($solicitacao);
            $status = $statusPara->status;
            $statusQuePrecisamSenhaSupervisor = $statusPara->status_que_precisam_senha_supervisor;
        }

        $hasStatusAgendamento = $status->whereIn('tipo_id', self::getStatusTipoDeAgendamento())->isNotEmpty();

        $statusReject = collect();

        if (self::getStatusTipoDeAgendamento()->contains($solicitacao->status->tipo_id)
            && !is_null($solicitacao->prestador_interno_id)
        ) {

            $statusReject->push(StatusTipo::REALIZADO);
        }

        if (self::getStatusTipoDeAgendamento()->contains($solicitacao->status->tipo_id)) {

            $statusReject->push(StatusTipo::SOLICITADO);
        }

        $permiteAgendar = self::permiteAgendar($solicitacao, $isPosicaoPorRegulador);

        if (!$permiteAgendar->permite) {

            $statusReject->push(StatusTipo::AGENDADO);
        }

        if (!self::getStatusTipoDeAgendamento()->contains($solicitacao->status->tipo_id)) {

            $statusReject->push(StatusTipo::REAGENDADO);
        }

        $status = $status->reject(fn ($s) => $statusReject->contains($s->tipo_id))->values();

        $unidadesUsuarioSolicitante = SolicitacaoService::getUnidadeProfissional(
            $solicitacao->usuario_solicitante_id
        )['form']['info_profissional']['unidades'];

        $infraestruturasUsuarioSolicitante = [];
        $ocupacoesUsuarioSolicitante = [];

        if (!is_null($solicitacao->lotaca_usuario_id) && !is_null($solicitacao->lotacaUsuario) && !is_null($solicitacao->lotacaUsuario->infraestrutura)) {

            $infraestruturasUsuarioSolicitante = SolicitacaoService::getInfraestruturaProfissional(
                $solicitacao->usuario_solicitante_id,
                $solicitacao->lotacaUsuario->infraestrutura->unidade_id
            )['form']['info_profissional']['infraestruturas'];

            $ocupacoesUsuarioSolicitante = SolicitacaoService::getOcupacaoProfissional(
                $solicitacao->usuario_solicitante_id,
                $solicitacao->lotacaUsuario->infraestrutura_id
            )['form']['info_profissional']['ocupacoes'];
        }

        return [
            'additionals' => [
                'data_atual' => Carbon::today()->format('d/m/Y'),
                'allow_update' => !$solicitacaoFinalizada,
                'modulo_agendamento' => self::getModuloAgendamento($solicitacao),
                'ambulatorio' => [
                    'cadastro_paciente_vencido' => ($parametrizacaoAmbulatorio->bloqueia_paciente_temporario ?? false)
                        && PacienteController::isCadastroPacienteVencido($solicitacao->paciente->id),
                    'avisa_cns_provisorio' => ($parametrizacaoAmbulatorio->avisa_cns_provisorio ?? false)
                        && Str::startsWith($solicitacao->paciente->cidadao->cns, [5, 7, 8, 9])
                ],
                'avisa_cns_temporario_invalido' => $cadastroParametrizacao->exibe_alerta_paciente_cns_temporario_invalido ?? false,
                'iniciou_atendimento' => $iniciouAtendimento,
                'permite_alterar_antropometria' => self::getStatusPermiteAlterarAntropometria()->contains($solicitacao->status->tipo_id),
                'exibe_protocolo_cross' => $parametrizacao->exibe_protocolo_cross ?? false,
                'obriga_protocolo_cross' => $parametrizacao->obriga_protocolo_cross ?? false,
                'usuario_registro_estado_id' => $parametrizacao->usuario_registro_estado_id ?? null,
                'status_que_precisam_senha_supervisor' => $statusQuePrecisamSenhaSupervisor,
                'precisa_senha_supervisor_para_agendar_fora_order_posicao' => $permiteAgendar->precisa_senha_supervisor,
                'precisa_senha_supervisor_para_agendar_outro_regulador' => $solicitacao->regulador->infraestrutura_id
                    !== self::getCurrentCentroCusto()->infraestrutura_id,
                'nome_usuario_logado' => self::getCurrentLotacao()->usuario->cidadao->nome,
                'faz_parte_oci' => !is_null($solicitacao->acompanhamento_oci_id)
                    || !is_null($solicitacao->acompanhamentoOciEtapaClincaConcluida),
                'agendado_prestador_externo' => !is_null($solicitacao->prestador_externo_id),
            ],
            'form' => [
                'paciente' => [
                    'id' => $solicitacao->paciente->id,
                    'nome' => $solicitacao->paciente->cidadao->nome
                        . (is_null($solicitacao->paciente->cidadao->nome_social)
                            ? '' : " ({$solicitacao->paciente->cidadao->nome_social})"),
                    'prontuario' => $solicitacao->paciente->prontuario,
                    'sexo_id' => $solicitacao->paciente->cidadao->sexo->id ?? null,
                    'sexo' => $solicitacao->paciente->cidadao->sexo->descricao ?? null,
                    'data_nascimento' => $solicitacao->paciente->cidadao->data_nascimento
                        ? (new Carbon($solicitacao->paciente->cidadao->data_nascimento))->format('d/m/Y')
                        : null,
                    'idade' => $solicitacao->paciente->cidadao->idade_formatada,
                    'raca_cor' => $solicitacao->paciente->cidadao->racaCor->descricao ?? null,
                    'cns' => MaskUtil::getCnsMasked($solicitacao->paciente->cidadao->cns),
                    'cpf' => MaskUtil::getCpfMasked($solicitacao->paciente->cidadao->cpf),
                    'rg' => $solicitacao->paciente->cidadao->carteiraIdentidade->numero ?? null,
                    'protocolo_cross' => $solicitacao->paciente->protocolo_cross ?? null,
                    'nome_mae' => $solicitacao->paciente->cidadao->nome_mae,
                    'endereco' => is_null($solicitacao->paciente->cidadao->domicilio_id)
                        ? null
                        : "{$solicitacao->paciente->cidadao->domicilio->endereco->completo} - "
                            . MaskUtil::getCepMasked($solicitacao->paciente->cidadao->domicilio->endereco->logradouro->cep),
                    'subclassificacao_id' => $solicitacao->paciente->subclassificacao_id,
                    'obito' => [
                        'usuario' => $solicitacao->paciente->cidadao->obito
                            && !is_null($solicitacao->paciente->cidadao->obito->usuario_id)
                            ? [
                                'id' => $solicitacao->paciente->cidadao->obito->usuario->id,
                                'cidadao_nome' => $solicitacao->paciente->cidadao->obito->usuario->cidadao->nome,
                                'cidadao_cns' => $solicitacao->paciente->cidadao->cns,
                            ]
                            : null,
                        'obito_em' => $solicitacao->paciente->cidadao->obito
                            ? (new Carbon($solicitacao->paciente->cidadao->obito->obito_em))->format('d/m/Y')
                            : null,
                        'declaracao' => $solicitacao->paciente->cidadao->obito->declaracao ?? null,
                        'causa' => $solicitacao->paciente->cidadao->obito->causa ?? null,
                        'cid' => $solicitacao->paciente->cidadao->obito
                            && !is_null($solicitacao->paciente->cidadao->obito->cid_id)
                            ? [
                                'id' => $solicitacao->paciente->cidadao->obito->cid->id,
                                'codigo' => $solicitacao->paciente->cidadao->obito->cid->codigo,
                                'nome' => $solicitacao->paciente->cidadao->obito->cid->nome,
                            ]
                            : null,
                    ]
                ],
                'status' => $status->sortBy('nome')->values()->each(fn ($s) => $s->makeHidden('pivot')),
                'opcoes_retirada_protocolo_agendamento' => ParametrizacaoOpcaoRetiradaProtocoloAgendamento::orderBy('nome')
                    ->get(['id', 'nome']),
                'prestadores_internos' => $hasStatusAgendamento
                    && collect([Tipo::AMBOS, Tipo::INTERNO])->contains($solicitacao->regulacao_tipo_id)
                    ? self::getPrestadoresInternos($solicitacao)
                    : collect(),
                'prestadores_externos' => $hasStatusAgendamento
                    && collect([Tipo::AMBOS, Tipo::EXTERNO])->contains($solicitacao->regulacao_tipo_id)
                    ? self::getPrestadoresExternos($solicitacao)
                    : collect(),
                'prestador_tipo' => $solicitacao->regulacao_tipo_id === Tipo::AMBOS
                    ? Tipo::INTERNO
                    : $solicitacao->regulacao_tipo_id,
                'solicitacao' => [
                    'id' => $solicitacao->id,
                    'prioridade_nome' => $solicitacao->prioridade->nome,
                    'data' => $solicitacao->data->format('d/m/Y'),
                    'cid' => is_null($solicitacao->cid_id)
                        ? null
                        : MaskUtil::getCidMasked($solicitacao->cid->codigo) . " - {$solicitacao->cid->nome}",
                    'ciap' => is_null($solicitacao->ciap_id)
                        ? null
                        : "{$solicitacao->ciap->codigo} - {$solicitacao->ciap->descricao}",
                    'numero' => $solicitacao->numero,
                    'regulacao_tipo_id' => $solicitacao->regulacao_tipo_id,
                    'ambulatorio_agendamento_id' => self::getAmbulatorioAgendamentoAtual($solicitacao)->id ?? null,
                    'exame_imagem_agendamento_id' => $solicitacao->exameImagemAgendamento->id ?? null,
                    'exame_laboratorial_agendamento_id' => $solicitacao->exameLaboratorialAgendamento->id ?? null,
                    'unidade_solicitante_id' => $solicitacao->infraestruturaSolicitante->unidade_id ?? null,
                    'infraestrutura_solicitante_id' => $solicitacao->infraestrutura_solicitante_id,
                    'usuario_solicitante_id' => $solicitacao->usuario_solicitante_id,
                    'usuario_solicitante_nome' => $solicitacao->usuarioSolicitante()->withTrashed()->first()->cidadao->nome,
                    'usuario_solicitante_registro_tipo' => isset($solicitacao->usuarioSolicitante)
                        ? (
                            $solicitacao->usuarioSolicitante->registro_tipo_id === TipoRegistroUsuario::OUTRO
                            ? $solicitacao->usuarioSolicitante->registro_tipo_outro
                            : ($solicitacao->usuarioSolicitante->registroTipo->sigla ?? null)
                        )
                        : null,
                    'usuario_solicitante_registro_numero' => $solicitacao->usuarioSolicitante->registro_numero ?? null,
                    'usuario_solicitante_registro_estado' => $solicitacao->usuarioSolicitante->registroEstado->uf ?? null,
                    'usuario_solicitante_ocupacao' => is_null($solicitacao->lotaca_usuario_id) || is_null($solicitacao->lotacaUsuario) || is_null($solicitacao->lotacaUsuario->ocupacao)
                        ? null
                        : "{$solicitacao->lotacaUsuario->ocupacao->codigo} - {$solicitacao->lotacaUsuario->ocupacao->nome}",
                    'hipotese_diagnostica_justificativa' => $solicitacao->hipotese_diagnostica_justificativa,
                    'is_urgente' => $solicitacao->prioridade_id === SolicitacaoPrioridade::URGENCIA,
                    'data_agendada' => $solicitacao->data_agendada
                        ? (new Carbon($solicitacao->data_agendada))->format('d/m/Y')
                        : null,
                    'observacao' => $solicitacao->observacao,
                    'itens' => $solicitacao->itens->map(function ($item) {

                        $exame = null;
                        $procedimentoCirurgico = null;
                        $especialidade = null;
                        $codigo = null;
                        $nome = null;

                        if (!is_null($item->exame_id)) {

                            $exame = $item->exame;
                            $exame->procedimento_id = $item->exame->procedimento->id ?? null;
                            $exame->procedimento_nome = $item->exame->procedimento->nome ?? null;
                            $exame->quantidade_maxima_execucao = $item->exame->procedimento->quantidade_maxima_execucao ?? null;
                            $exame->valor_servico_ambilatorial = $item->exame->procedimento->valor_servico_ambilatorial ?? null;
                            $exame->sexo = $item->exame->procedimento->sexo ?? null;
                            $exame->acompanhamento_oci_id = $item->faz_parte_oci ? $item->solicitacao->acompanhamento_oci_id : null;
                            $codigo = MaskUtil::getProcedimentoMasked($item->exame->codigo);
                            $nome = $item->exame->nome;
                        }
                        else if (!is_null($item->procedimento_cirurgico_id)) {

                            $procedimentoCirurgico = $item->procedimentoCirurgico;
                            $codigo = MaskUtil::getProcedimentoMasked($item->procedimentoCirurgico->procedimento_codigo);
                            $nome = $item->procedimentoCirurgico->nome;
                        }
                        else if (!is_null($item->especialidade_id)) {

                            $especialidade = $item->especialidade;
                            $codigo = $item->especialidade->ocupacao->codigo;
                            $nome = $item->especialidade->nome;
                        }

                        return [
                            'id' => $item->id,
                            'exame' => $exame,
                            'procedimento_cirurgico' => $procedimentoCirurgico,
                            'especialidade' => $especialidade,
                            'codigo' => $codigo,
                            'nome' => $nome,
                        ];
                    }),
                    'oci_etapa_clinica_atual_nome' => $solicitacao->acompanhamentoOci->etapaClinicaAtual->nome ?? null
                ],
                'unidades_usuario_solicitante' => $unidadesUsuarioSolicitante,
                'infraestruturas_usuario_solicitante' => $infraestruturasUsuarioSolicitante,
                'ocupacoes_usuario_solicitante' => $ocupacoesUsuarioSolicitante,
                'historico_movimentacoes' => self::getHistoricoMovimentacoesSolicitacao($solicitacao->id),
                'historico_outras_solicitacoes' => self::getOutrasSolicitacoesPaciente($solicitacao),
                'historico_ambulatorio' => self::getDadosAmbulatorio($solicitacao->id, false) ?? null,
                'historico_oci' => self::getHistoricoOci($solicitacao),
            ],
            'model' => [
                'obito' => !is_null($solicitacao->paciente->cidadao->obito),
                'peso' => $solicitacao->peso,
                'altura' => $solicitacao->altura,
                'status_id' => null,
                'opcao_retirada_protocolo_agendamento_id' => $parametrizacao->opcao_retirada_protocolo_agendamento_id
                    ?? OpcaoRetiradaProtocoloAgendamento::NAO_INFORMADO,
                'nome_pessoa_retirada_protocolo_agendamento' => $solicitacao->paciente->cidadao->nome,
                'prestador_interno_id' => null,
                'prestador_externo_id' => null,
                'data_agendada' => null,
                'hora_agendada' => null,
                'ocupacao_executora' => null,
                'usuario_executor_nome' => null,
                'justificativa_cancelamento' => null,
                'justificativa_reagendamento' => null,
                'justificativa_remarcacao' => null,
                'justificativa_devolucao' => null,
                'justificativa_reenvio' => null,
                'justificativa_falta' => null,
                'usuario_solicitante' => [
                    'id' => $solicitacao->usuarioSolicitante()->withTrashed()->first()->id,
                    'cidadao_nome' => $solicitacao->usuarioSolicitante()->withTrashed()->first()->cidadao->nome,
                    'registro_tipo_id' => $solicitacao->usuarioSolicitante()->withTrashed()->first()->registro_tipo_id,
                ],
                'unidade_usuario_solicitante_id' => $solicitacao->lotacaUsuario->infraestrutura->unidade_id ?? null,
                'infraestrutura_usuario_solicitante_id' => $solicitacao->lotacaUsuario->infraestrutura_id ?? null,
                'ocupacao_usuario_solicitante_id' => $solicitacao->lotacaUsuario->ocupacao_id ?? null,
                'cid' => is_null($solicitacao->cid_id)
                    ? null
                    : [
                        'id' => $solicitacao->cid->id,
                        'codigo' => $solicitacao->cid->codigo,
                        'nome' => $solicitacao->cid->nome,
                    ],
                'ciap' => is_null($solicitacao->ciap_id)
                    ? null
                    : [
                        'id' => $solicitacao->ciap->id,
                        'codigo' => $solicitacao->ciap->codigo,
                        'descricao' => $solicitacao->ciap->descricao,
                    ],
                'hipotese_diagnostica_justificativa' => $solicitacao->hipotese_diagnostica_justificativa,
                'observacao' => $solicitacao->observacao,
                'soap_id' => $solicitacao->soap_id ?? null,
                'id' => $solicitacao->id,
            ],
        ];
    }

    private static function getStatusPara($solicitacao)
    {
        $centroCustoLogado = self::getCurrentCentroCusto();

        $isSolicitanteOuReferencia = $solicitacao->infraestrutura_solicitante_id === $centroCustoLogado->infraestrutura_id
            || $solicitacao->paciente->unidade_id === $centroCustoLogado->infraestrutura->unidade_id;

        $isRegulador = $solicitacao->regulador->infraestrutura_id === $centroCustoLogado->infraestrutura_id;

        $statusTiposIds = collect();

        if ($isSolicitanteOuReferencia && $isRegulador) {

            $statusTiposIds = self::getStatusTiposQueReguladorPodeEncaminhar()
                ->merge(self::getStatusTiposQueSolicitantePodeEncaminhar());
        }
        else if ($isSolicitanteOuReferencia) {

            $statusTiposIds = self::getStatusTiposQueSolicitantePodeEncaminhar();

            if (collect([
                StatusTipo::SOLICITADO,
                StatusTipo::DEVOLVIDO,
                StatusTipo::REENVIADA,
                StatusTipo::EM_ESPERA,
                StatusTipo::REMARCAR,
            ])->contains($solicitacao->status->tipo_id)) {

                $statusTiposIds->push(StatusTipo::CANCELADO);
            }
        }
        else if ($isRegulador) {

            $statusTiposIds = self::getStatusTiposQueReguladorPodeEncaminhar();
        }

        $status = collect();
        $statusQuePrecisamSenhaSupervisor = collect();

        if (self::isSupervisor()) {

            $status = $solicitacao->status->statusPara()
                ->get(['id', 'tipo_id', 'nome']);

            $statusQuePrecisamSenhaSupervisor = $status
                ->filter(fn ($s) => !$statusTiposIds->contains($s->tipo_id))
                ->map(fn ($s) => $s->id)
                ->values();
        }
        else {

            $status = $solicitacao->status->statusPara()
                ->whereIn('tipo_id', $statusTiposIds)
                ->get(['id', 'tipo_id', 'nome']);
        }

        return (object) [
            'status' => $status,
            'status_que_precisam_senha_supervisor' => $statusQuePrecisamSenhaSupervisor,
        ];
    }

    private static function iniciouAtendimento($solicitacao)
    {
        if ($agendamento = self::getAmbulatorioAgendamentoAtual($solicitacao)) {

            return !is_null($agendamento->atendimento);
        }
        else if ($agendamento = $solicitacao->exameImagemAgendamento) {

            return ExameImagemAgendamentoExame::where('agendamento_id', $agendamento->id)
                ->where('status_id', '<>', ExameImagemAgendamentoStatus::AGENDADO)
                ->exists();
        }
        else if ($agendamento = $solicitacao->exameLaboratorialAgendamento) {

            return ExameLaboratorialAgendamentoExame::where('agendamento_id', $agendamento->id)
                ->where('status_id', '<>', ExameLaboratorialAgendamentoStatus::AGENDADO)
                ->exists();
        }

        return false;
    }

    private static function permiteAgendar($solicitacao, $isPosicaoPorRegulador)
    {
        $solicitacaoFinalizada = self::getStatusTiposQueFinalizamSolicitacao()->contains($solicitacao->status->tipo_id);
        $permite = false;
        $precisaSenhaSupervisor = false;

        if ($solicitacaoFinalizada || $solicitacao->status->tipo_id === StatusTipo::AGENDADO) {

            $permite = false;
        }
        else if (Parametrizacao::first()->permite_agendar_fora_ordem_posicao ?? false) {

            $permite = true;
        }
        else {

            $filterItem = fn ($q) => SolicitacaoService::filterItemPosicao($q, $solicitacao->itens()->first());

            if ($isPosicaoPorRegulador) {

                $primeiraPosicaoReguladorParaAgendamento = Solicitacao::where('regulador_id', $solicitacao->regulador_id)
                    ->whereNotNull('posicao_regulador')
                    ->whereHas('status', fn ($q) => $q->whereNotIn('tipo_id', self::getStatusTipoDeAgendamento()))
                    ->whereHas('itens', $filterItem)
                    ->min('posicao_regulador');

                $permite = $solicitacao->posicao_regulador === $primeiraPosicaoReguladorParaAgendamento;
            }
            else {

                $primeiraPosicaoMunicipalParaAgendamento = Solicitacao::whereNotNull('posicao_municipal')
                    ->whereHas('status', fn ($q) => $q->whereNotIn('tipo_id', self::getStatusTipoDeAgendamento()))
                    ->whereHas('itens', $filterItem)
                    ->min('posicao_municipal');

                $permite = $solicitacao->posicao_municipal === $primeiraPosicaoMunicipalParaAgendamento;
            }

            if (!$permite && self::isSupervisor()) {

                $permite = true;
                $precisaSenhaSupervisor = true;
            }
        }

        return (object) [
            'permite' => $permite,
            'precisa_senha_supervisor' => $precisaSenhaSupervisor,
        ];
    }

    private static function getModuloAgendamento($solicitacao)
    {
        $moduloAgendamento = null;

        if ($exame = $solicitacao->itens->first()->exame) {

            if ($exame->tipo_id === ExameTipo::LABORATORIAL) {

                $moduloAgendamento = 'exame-laboratorial';
            }
            else if ($exame->tipo_id === ExameTipo::IMAGEM) {

                $moduloAgendamento = 'exame-imagem';
            }
        }
        else if ($solicitacao->itens->first()->especialidade) {

            $moduloAgendamento = 'ambulatorio';
        }

        return $moduloAgendamento;
    }

    private static function getPrestadoresInternos($solicitacao)
    {
        $prestadores = collect();
        $itensIds = self::getItensIds($solicitacao);

        ParametrizacaoPrestadorInterno::where('ativo', true)
            ->get()
            ->each(function ($prestador) use ($prestadores, $itensIds) {

                $addPrestador = true;

                if ($itensIds->exames_ids->isNotEmpty()) {

                    $itensIds->exames_ids->each(function ($id) use ($prestador, &$addPrestador) {

                        if (!$prestador->exames()->where('id', $id)->wherePivot('ativo', true)->exists()) {

                            $addPrestador = false;

                            return false;
                        }
                    });
                }
                else if ($itensIds->procedimentos_cirurgicos_ids->isNotEmpty()) {

                    $itensIds->procedimentos_cirurgicos_ids->each(function ($id) use ($prestador, &$addPrestador) {

                        if (!$prestador->procedimentosCirurgicos()->where('id', $id)->wherePivot('ativo', true)->exists()) {

                            $addPrestador = false;

                            return false;
                        }
                    });
                }
                else if ($itensIds->especialidades_ids->isNotEmpty()) {

                    $itensIds->especialidades_ids->each(function ($id) use ($prestador, &$addPrestador) {

                        if (!$prestador->especialidades()->where('id', $id)->wherePivot('ativo', true)->exists()) {

                            $addPrestador = false;

                            return false;
                        }
                    });
                }

                if ($addPrestador) {

                    $prestadores->push((object) [
                        'id' => $prestador->id,
                        'unidade_id' => $prestador->infraestrutura->unidade_id,
                        'infraestrutura_id' => $prestador->infraestrutura_id,
                        'nome' => $prestador->infraestrutura->principal
                            ? $prestador->infraestrutura->unidade->nome_fantasia
                            : "{$prestador->infraestrutura->unidade->nome_fantasia} - {$prestador->infraestrutura->nome}"
                    ]);
                }
            });

        return $prestadores->sortBy('nome')->values();
    }

    private static function getPrestadoresExternos($solicitacao)
    {
        $prestadores = collect();
        $itensIds = self::getItensIds($solicitacao);

        ParametrizacaoPrestadorExterno::where('ativo', true)
            ->get()
            ->each(function ($prestador) use ($prestadores, $itensIds) {

                $addPrestador = true;

                if ($itensIds->exames_ids->isNotEmpty()) {

                    $itensIds->exames_ids->each(function ($id) use ($prestador, &$addPrestador) {

                        if (!$prestador->exames()->where('id', $id)->wherePivot('ativo', true)->exists()) {

                            $addPrestador = false;

                            return false;
                        }
                    });
                }
                else if ($itensIds->procedimentos_cirurgicos_ids->isNotEmpty()) {

                    $itensIds->procedimentos_cirurgicos_ids->each(function ($id) use ($prestador, &$addPrestador) {

                        if (!$prestador->procedimentosCirurgicos()->where('id', $id)->wherePivot('ativo', true)->exists()) {

                            $addPrestador = false;

                            return false;
                        }
                    });
                }
                else if ($itensIds->especialidades_ids->isNotEmpty()) {

                    $itensIds->especialidades_ids->each(function ($id) use ($prestador, &$addPrestador) {

                        if (!$prestador->especialidades()->where('id', $id)->wherePivot('ativo', true)->exists()) {

                            $addPrestador = false;

                            return false;
                        }
                    });
                }

                if ($addPrestador) {

                    $prestadores->push((object) [
                        'id' => $prestador->id,
                        'nome' => $prestador->destino->descricao_destino
                    ]);
                }
            });

        return $prestadores->sortBy('nome')->values();
    }

    private static function getItensIds($solicitacao)
    {
        $examesIds = collect();
        $procedimentosCirurgicosIds = collect();
        $especialidadesIds = collect();

        $solicitacao->itens->each(function ($item) use ($examesIds, $procedimentosCirurgicosIds, $especialidadesIds) {

            if (!is_null($item->exame_id)) {

                $examesIds->push($item->exame_id);
            }
            else if (!is_null($item->procedimento_cirurgico_id)) {

                $procedimentosCirurgicosIds->push($item->procedimento_cirurgico_id);
            }
            else if (!is_null($item->especialidade_id)) {

                $especialidadesIds->push($item->especialidade_id);
            }
        });

        return (object) [
            'exames_ids' => $examesIds,
            'procedimentos_cirurgicos_ids' => $procedimentosCirurgicosIds,
            'especialidades_ids' => $especialidadesIds,
        ];
    }

    public static function getHistoricoMovimentacoesSolicitacao($solicitacaoId)
    {
        $movimentacoesStatus = collect();
        $movimentacoesPrioridade = collect();

        $statusAnteriorId = null;
        $prioridadeAnterior = ['id' => null, 'nome' => null];

        DB::table('regulacao_solicitacao_historico as solicitacao_historico')
            ->join('regulacao_status as status', 'status.id', 'solicitacao_historico.status_id')
            ->join('regulacao_solicitacao_prioridade as prioridade', 'prioridade.id', 'solicitacao_historico.prioridade_id')
            ->join(
                'cadastro_lotacao as lotacao',
                'lotacao.id',
                'solicitacao_historico.created_lotacao_id'
            )
            ->join(
                'cadastro_usuario as usuario',
                'usuario.id',
                'lotacao.usuario_id'
            )
            ->join(
                'cadastro_cidadao as cidadao',
                'cidadao.id',
                'usuario.cidadao_id'
            )
            ->leftJoin(
                'regulacao_parametrizacao_prestador_interno as prestador_interno',
                'prestador_interno.id',
                'solicitacao_historico.prestador_interno_id'
            )
            ->leftJoin(
                'cadastro_infraestrutura as prestador_interno_infraestrutura',
                'prestador_interno_infraestrutura.id',
                'prestador_interno.infraestrutura_id'
            )
            ->leftJoin(
                'cadastro_unidade as prestador_interno_unidade',
                'prestador_interno_unidade.id',
                'prestador_interno_infraestrutura.unidade_id'
            )
            ->leftJoin(
                'regulacao_parametrizacao_prestador_externo as prestador_externo',
                'prestador_externo.id',
                'solicitacao_historico.prestador_externo_id'
            )
            ->leftJoin(
                'transporte_paciente_destino as prestador_externo_destino',
                'prestador_externo_destino.id',
                'prestador_externo.destino_id'
            )
            ->leftJoin(
                'regulacao_parametrizacao_opcao_retirada_protocolo_agendamento as opcao_retirada_protocolo_agendamento',
                'opcao_retirada_protocolo_agendamento.id',
                'solicitacao_historico.opcao_retirada_protocolo_agendamento_id'
            )
            ->where('solicitacao_historico.solicitacao_id', $solicitacaoId)
            ->selectRaw("
                solicitacao_historico.id as solicitacao_historico_id,
                status.id as status_id,
                status.nome as status_nome,
                prioridade.id as prioridade_id,
                prioridade.nome as prioridade_nome,
                (
                    CASE
                        WHEN solicitacao_historico.prestador_interno_id IS NOT NULL
                            THEN IF (prestador_interno_infraestrutura.nome IS NULL,
                                prestador_interno_unidade.nome_fantasia,
                                CONCAT(prestador_interno_unidade.nome_fantasia, ' (', prestador_interno_infraestrutura.nome, ')')
                            )
                        WHEN solicitacao_historico.prestador_externo_id IS NOT NULL
                            THEN prestador_externo_destino.descricao_destino
                        ELSE NULL
                    END
                ) as prestador_descricao,
                solicitacao_historico.data_agendada,
                DATE_FORMAT(solicitacao_historico.hora_agendada, '%H:%i') as hora_agendada,
                opcao_retirada_protocolo_agendamento.nome as opcao_retirada_protocolo_agendamento_nome,
                solicitacao_historico.nome_pessoa_retirada_protocolo_agendamento,
                solicitacao_historico.created_at as data_hora_movimentacao,
                cidadao.nome as usuario_que_movimentou,
                solicitacao_historico.motivo_alteracao_prioridade,
                (
                    CASE status.tipo_id
                        WHEN " . StatusTipo::CANCELADO . " THEN solicitacao_historico.justificativa_cancelamento
                        WHEN " . StatusTipo::REAGENDADO . " THEN solicitacao_historico.justificativa_reagendamento
                        WHEN " . StatusTipo::REMARCAR . " THEN solicitacao_historico.justificativa_remarcacao
                        WHEN " . StatusTipo::DEVOLVIDO . " THEN solicitacao_historico.justificativa_devolucao
                        WHEN " . StatusTipo::REENVIADA . " THEN solicitacao_historico.justificativa_reenvio
                        WHEN " . StatusTipo::FALTA . " THEN solicitacao_historico.justificativa_falta
                    END
                ) as justificativa_status
            ")
            ->orderBy('solicitacao_historico.created_at')
            ->get()
            ->each(function ($movimentacao) use (&$statusAnteriorId, &$prioridadeAnterior, $movimentacoesStatus, $movimentacoesPrioridade) {

                if ($movimentacao->status_id !== $statusAnteriorId) {

                    $movimentacoesStatus->push($movimentacao);
                }

                if ($movimentacao->prioridade_id !== $prioridadeAnterior['id']) {

                    $movimentacao->prioridade_anterior_nome = $prioridadeAnterior['nome'];
                    $movimentacoesPrioridade->push($movimentacao);
                }

                $statusAnteriorId = $movimentacao->status_id;

                $prioridadeAnterior = [
                    'id' => $movimentacao->prioridade_id,
                    'nome' => $movimentacao->prioridade_nome,
                ];
            });

        return [
            'status' => $movimentacoesStatus,
            'prioridade' => $movimentacoesPrioridade,
        ];
    }

    public static function getOutrasSolicitacoesPaciente($solicitacao)
    {
        $solicitacoes = DB::table('regulacao_solicitacao as solicitacao')
            ->join('regulacao_status as status', 'status.id', 'solicitacao.status_id')
            ->join(
                'regulacao_parametrizacao_regulador as regulador',
                'regulador.id',
                'solicitacao.regulador_id'
            )
            ->join(
                'cadastro_infraestrutura as infraestrutura_reguladora',
                'infraestrutura_reguladora.id',
                'regulador.infraestrutura_id'
            )
            ->join(
                'cadastro_unidade as unidade_reguladora',
                'unidade_reguladora.id',
                'infraestrutura_reguladora.unidade_id'
            )
            ->join(
                'cadastro_infraestrutura as infraestrutura_solicitante',
                'infraestrutura_solicitante.id',
                'solicitacao.infraestrutura_solicitante_id'
            )
            ->join(
                'cadastro_unidade as unidade_solicitante',
                'unidade_solicitante.id',
                'infraestrutura_solicitante.unidade_id'
            )
            ->join(
                'cadastro_usuario as usuario_solicitante',
                'usuario_solicitante.id',
                'solicitacao.usuario_solicitante_id'
            )
            ->join(
                'cadastro_cidadao as usuario_cidadao_solicitante',
                'usuario_cidadao_solicitante.id',
                'usuario_solicitante.cidadao_id'
            )
            ->join('regulacao_solicitacao_item as item', 'item.solicitacao_id', 'solicitacao.id')
            ->leftJoin('parametrizacao_exame as exame', 'exame.id', 'item.exame_id')
            ->leftJoin(
                'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                'procedimento_cirurgico.id',
                'item.procedimento_cirurgico_id'
            )
            ->leftJoin('cadastro_especialidade as especialidade', 'especialidade.id', 'item.especialidade_id')
            ->leftJoin('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
            ->whereNotNull('solicitacao.confirmado_em')
            ->where('solicitacao.id', '<>', $solicitacao->id)
            ->where('solicitacao.paciente_id', $solicitacao->paciente_id)
            ->selectRaw("
                solicitacao.id,
                solicitacao.data,
                usuario_cidadao_solicitante.nome as usuario_solicitante_nome,
                unidade_solicitante.nome_fantasia as unidade_solicitante_nome_fantasia,
                COALESCE(infraestrutura_solicitante.nome, unidade_solicitante.nome_fantasia) as infraestrutura_solicitante_nome,
                unidade_reguladora.nome_fantasia as unidade_reguladora_nome_fantasia,
                COALESCE(infraestrutura_reguladora.nome, unidade_reguladora.nome_fantasia) as infraestrutura_reguladora_nome,
                status.nome as status_nome,
                GROUP_CONCAT((
                    CASE
                        WHEN item.exame_id IS NOT NULL
                            THEN IF (exame.codigo IS NULL OR exame.codigo = '',
                                exame.nome,
                                CONCAT(
                                    CONCAT(
                                        SUBSTR(exame.codigo, 1, 2),
                                        '.',
                                        SUBSTR(exame.codigo, 3, 2),
                                        '.',
                                        SUBSTR(exame.codigo, 5, 2),
                                        '.',
                                        SUBSTR(exame.codigo, 7, 3),
                                        '-',
                                        SUBSTR(exame.codigo, 10, 1)
                                    ),
                                    ' - ',
                                    exame.nome
                                )
                            )
                        WHEN item.procedimento_cirurgico_id IS NOT NULL
                            THEN CONCAT(
                                CONCAT(
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 1, 2),
                                    '.',
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 3, 2),
                                    '.',
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 5, 2),
                                    '.',
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 7, 3),
                                    '-',
                                    SUBSTR(procedimento_cirurgico.procedimento_codigo, 10, 1)
                                ),
                                ' - ',
                                procedimento_cirurgico.nome
                            )
                        WHEN item.especialidade_id IS NOT NULL
                            THEN CONCAT(ocupacao.codigo, ' - ', especialidade.nome)
                    END
                ) SEPARATOR '#') AS itens
            ")
            ->groupByRaw("
                solicitacao.id,
                solicitacao.data,
                usuario_cidadao_solicitante.nome,
                unidade_solicitante.nome_fantasia,
                COALESCE(infraestrutura_solicitante.nome, unidade_solicitante.nome_fantasia),
                unidade_reguladora.nome_fantasia,
                COALESCE(infraestrutura_reguladora.nome, unidade_reguladora.nome_fantasia),
                status.nome
            ")
            ->get();

        $solicitacoes->each(function ($solicitacao) {

            $solicitacao->itens = explode('#', $solicitacao->itens);
        });

        return $solicitacoes;
    }
    public static function saveHistoricoPaciente($pacienteId){
        $historico = new PacienteHistorico();
        $historico->paciente_id = $pacienteId;
        $historico->save();
    }

    public static function updatePaciente($pacienteId)
    {
        $paciente = Paciente::findOrFail($pacienteId);

        self::validateUpdatePaciente($paciente);

        DB::transaction(function () use ($paciente) {
            $cidadao = Cidadao::find($paciente->cidadao_id);
            $cidadao->update([
                'cns' => request()->cns,
                'cpf' => request()->cpf,
            ]);

            $carteiraIdentidade = $paciente->cidadao->carteiraIdentidade;

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

                if ($carteiraIdentidade) {

                    $carteiraIdentidade->delete();
                }
            }
            else {

                if ($carteiraIdentidade) {

                    $carteiraIdentidade->update(['numero' => request()->rg]);
                }
                else {

                    $paciente->cidadao->carteiraIdentidade()->create([
                        'numero' => request()->rg,
                    ]);
                }
            }

            $parametrizacao = Parametrizacao::first();

            if ($parametrizacao->exibe_protocolo_cross ?? false) {

                $paciente->update([
                    'protocolo_cross' => request()->protocolo_cross ?? null,
                ]);
            }
            self::saveHistoricoPaciente($paciente->id);
        });

        return $paciente->fresh();
    }

    private static function validateUpdatePaciente($paciente)
    {
        $parametrizacao = Parametrizacao::first();

        return request()->validate([
            'cns' => [
                'nullable',
                'digits:15',
                new Cns,
                'unique:\App\Models\Cadastro\SujeitoAtencao\Cidadao,cns,'
                    . ($paciente->cidadao->id) . ',id,deleted_at,NULL',
            ],
            'cpf' => [
                'nullable',
                'digits:11',
                new Cpf,
            ],
            'rg' => [
                'nullable',
                'string',
                'between:6,15',
                Rule::unique('\App\Models\Cadastro\SujeitoAtencao\CarteiraIdentidade', 'numero')
                    ->where(fn ($q) => $q->where('cidadao_id', '!=', $paciente->cidadao->id)
                        ->whereNull('deleted_at')),
            ],
            'protocolo_cross' => [
                'nullable',
                Rule::requiredIf(fn () => $parametrizacao->obriga_protocolo_cross ?? false),
                'digits_between:1,10',
            ],
        ], [
            'cns.unique' => 'O CNS já está vinculado a outro cidadão.',
            'rg.unique' => 'O número da Carteira de identidade já está vinculado a outro cidadão.',
        ]);
    }

    public static function editPrioridade($solicitacaoId)
    {
        $solicitacao = Solicitacao::findOrFail($solicitacaoId);

        return [
            'form' => [
                'prioridades' => RegulacaoSolicitacaoPrioridade::where('id', '<>', $solicitacao->prioridade_id)
                    ->orderBy('nome')
                    ->get(['id', 'nome']),
                'prioridade_atual_nome' => $solicitacao->prioridade->nome,
            ],
            'model' => [
                'prioridade_id' => null,
                'motivo' => null
            ],
        ];
    }

    public static function updatePrioridade($solicitacaoId)
    {
        self::validateUpdatePrioridade();

        SolicitacaoService::updatePrioridade($solicitacaoId, request()->prioridade_id, request()->motivo);
    }

    private static function validateUpdatePrioridade()
    {
        request()->validate([
            'prioridade_id' => [
                'required',
                'integer',
                Rule::exists(RegulacaoSolicitacaoPrioridade::class, 'id')
            ],
            'motivo' => [
                'required',
                'string',
                'max:200'
            ],
        ]);
    }

    public static function updateSolicitacao($solicitacaoId)
    {
        $solicitacao = Solicitacao::findOrFail($solicitacaoId);

        if (self::getStatusTiposQueFinalizamSolicitacao()->contains($solicitacao->status->tipo_id)) {

            throw new CannotUpdateSolicitacaoException();
        }

        self::validateUpdateSolicitacao($solicitacao);

        DB::transaction(function () use ($solicitacao) {

            self::saveObito($solicitacao->paciente);

            $posicaoMunicipalAnterior = $solicitacao->posicao_municipal;
            $posicaoReguladorAnterior = $solicitacao->posicao_regulador;
            $posicaoPortalAnterior = $solicitacao->posicao_portal;

            $solicitacao->update(self::getSolicitacaoUpdateParams($solicitacao));

            SolicitacaoService::saveHistorico($solicitacao);

            $solicitacao->refresh();

            if (collect([StatusTipo::AGENDADO, StatusTipo::REAGENDADO])->contains($solicitacao->status->tipo_id)) {

                if (!is_null($posicaoPortalAnterior)) {

                    SolicitacaoService::decrementPositionsPortalAfter(
                        $posicaoPortalAnterior,
                        $solicitacao->itens()->first()
                    );
                }
            }
            else if (self::getStatusTiposQueAlteramPosicoes()->contains($solicitacao->status->tipo_id)) {

                SolicitacaoService::decrementPositionsAfter(
                    $posicaoMunicipalAnterior,
                    $solicitacao->regulador_id,
                    $posicaoReguladorAnterior,
                    $solicitacao->itens()->first()
                );

                if (!is_null($posicaoPortalAnterior)) {

                    SolicitacaoService::decrementPositionsPortalAfter(
                        $posicaoPortalAnterior,
                        $solicitacao->itens()->first()
                    );
                }

                if ($solicitacao->status->tipo_id === StatusTipo::REMARCAR) {

                    $posicoes = SolicitacaoService::getProximasPosicoes(
                        $solicitacao->prioridade_id,
                        $solicitacao->regulador_id,
                        $solicitacao->itens()->first()
                    );

                    $posicaoPortal = SolicitacaoService::getProximaPosicaoPortal(
                        $solicitacao->prioridade_id,
                        $solicitacao->itens()->first()
                    );

                    $solicitacao->update([
                        'posicao_municipal' => $posicoes->posicao_municipal,
                        'posicao_regulador' => $posicoes->posicao_regulador,
                        'posicao_portal' => $posicaoPortal,
                    ]);

                    SolicitacaoService::saveHistorico($solicitacao);
                }
            }

            self::updateStatusNoModuloDeAgendamento($solicitacao);
        });

        return $solicitacao->fresh();
    }

    private static function saveObito($paciente)
    {
        $obito = $paciente->cidadao->obito;

        if (is_null(request()->paciente['obito']['obito_em'])) {

            if ($obito) {

                $obito->delete();
            }
        }
        else {

            $params = request()->paciente['obito'];
            $params['obito_em'] = Carbon::createFromFormat('d/m/Y', $params['obito_em'])->startOfDay();

            if (is_null($obito)) {

                $paciente->cidadao->obito()->create($params);
            }
            else {

                $obito->update($params);
            }
        }
    }

    private static function validateUpdateSolicitacao($solicitacao)
    {
        $statusTipoId = Status::where('id', request()->status_id)->first('tipo_id')->tipo_id ?? null;
        $isStatusTipoAgendamento = collect([StatusTipo::AGENDADO, StatusTipo::REAGENDADO])->contains($statusTipoId);
        $isStatusReenviada = $statusTipoId === StatusTipo::REENVIADA;

        return request()->validate([
            'paciente.obito.obito_em' => [
                'nullable',
                'date_format:d/m/Y',
                'before_or_equal:' . Carbon::today()->format('d/m/Y'),
            ],
            'paciente.obito.declaracao' => [
                'nullable',
                'string',
                'between:1,13',
            ],
            'paciente.obito.causa' => [
                'nullable',
                'string',
                'between:1,255',
            ],
            'paciente.obito.cid_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'paciente.obito.usuario_id' => [
                'nullable',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'peso' => [
                'nullable',
                'numeric',
                'between:0.5,500',
            ],
            'altura' => [
                'nullable',
                'numeric',
                'between:20,250',
            ],
            'status_id' => [
                'required',
                'integer',
                Rule::exists(Status::class, 'id'),
            ],
            'opcao_retirada_protocolo_agendamento_id' => [
                'nullable',
                Rule::requiredIf(fn () => $isStatusTipoAgendamento),
                Rule::exists(ParametrizacaoOpcaoRetiradaProtocoloAgendamento::class, 'id'),
            ],
            'nome_pessoa_retirada_protocolo_agendamento' => [
                'nullable',
                Rule::requiredIf(fn () => $isStatusTipoAgendamento && request()
                    ->opcao_retirada_protocolo_agendamento_id === OpcaoRetiradaProtocoloAgendamento::RETIRADO),
                'string',
                'max:150',
            ],
            'prestador_interno_id' => [
                'nullable',
                Rule::requiredIf(fn () => $isStatusTipoAgendamento
                    && ($solicitacao->regulacao_tipo_id === Tipo::INTERNO
                        || ($solicitacao->regulacao_tipo_id === Tipo::AMBOS && is_null(request()->prestador_externo_id)))
                ),
                Rule::exists(ParametrizacaoPrestadorInterno::class, 'id'),
            ],
            'prestador_externo_id' => [
                'nullable',
                Rule::requiredIf(fn () => $isStatusTipoAgendamento
                    && ($solicitacao->regulacao_tipo_id === Tipo::EXTERNO
                        || ($solicitacao->regulacao_tipo_id === Tipo::AMBOS && is_null(request()->prestador_interno_id)))
                ),
                Rule::exists(ParametrizacaoPrestadorExterno::class, 'id'),
            ],
            'data_agendada' => [
                'nullable',
                Rule::requiredIf(fn () => !is_null(request()->prestador_externo_id)),
                'date_format:d/m/Y',
                'after_or_equal:' . Carbon::today()->format('d/m/Y'),
            ],
            'hora_agendada' => [
                'nullable',
                Rule::requiredIf(fn () => !is_null(request()->prestador_externo_id)),
                'date_format:H:i',
            ],
            'ocupacao_executora_id' => [
                'nullable',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'usuario_executor_nome' => [
                'nullable',
                'string',
                'max:100',
            ],
            'justificativa_cancelamento' => [
                'nullable',
                Rule::requiredIf(fn () => $statusTipoId === StatusTipo::CANCELADO),
                'string',
                'max:1000',
            ],
            'justificativa_reagendamento' => [
                'nullable',
                Rule::requiredIf(fn () => $statusTipoId === StatusTipo::REAGENDADO),
                'string',
                'max:1000',
            ],
            'justificativa_remarcacao' => [
                'nullable',
                Rule::requiredIf(fn () => $statusTipoId === StatusTipo::REMARCAR),
                'string',
                'max:1000',
            ],
            'justificativa_devolucao' => [
                'nullable',
                Rule::requiredIf(fn () => $statusTipoId === StatusTipo::DEVOLVIDO),
                'string',
                'max:1000',
            ],
            'justificativa_reenvio' => [
                'nullable',
                Rule::requiredIf(fn () => $statusTipoId === StatusTipo::REENVIADA),
                'string',
                'max:1000',
            ],
            'justificativa_falta' => [
                'nullable',
                Rule::requiredIf(fn () => $statusTipoId === StatusTipo::FALTA),
                'string',
                'max:1000',
            ],
            'lotacao_usuario_solicitante_id' => [
                'nullable',
                Rule::requiredIf(fn () => $isStatusReenviada),
                'integer',
                Rule::exists(Lotacao::class, 'id'),
            ],
            'cid_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'ciap_id' => [
                'nullable',
                Rule::requiredIf(fn () => $isStatusReenviada && (Usuario::find(request()->usuario_solicitante_id)
                    ->registro_tipo_id ?? null) === TipoRegistroUsuario::ENFERMAGEM),
                'integer',
                Rule::exists(Ciap::class, 'id'),
            ],
            'hipotese_diagnostica_justificativa' => [
                'nullable',
                'string',
                'max:5000',
            ],
            'observacao' => [
                'nullable',
                'string',
                'max:5000',
            ],
        ]);
    }

    private static function getSolicitacaoUpdateParams($solicitacao)
    {
        $params = [
            'status_id' => request()->status_id,
        ];

        if (self::getStatusPermiteAlterarAntropometria()->contains($solicitacao->status->tipo_id)) {

            $params['peso'] = request()->peso;
            $params['altura'] = request()->altura;
        }

        $statusTipoId = Status::findOrFail($params['status_id'])->tipo_id;

        if (collect([StatusTipo::AGENDADO, StatusTipo::REAGENDADO])->contains($statusTipoId)) {

            $params['posicao_portal'] = null;
            $params['opcao_retirada_protocolo_agendamento_id'] = request()->opcao_retirada_protocolo_agendamento_id;

            $params['nome_pessoa_retirada_protocolo_agendamento'] = $params['opcao_retirada_protocolo_agendamento_id']
                === OpcaoRetiradaProtocoloAgendamento::RETIRADO
                ? request()->nome_pessoa_retirada_protocolo_agendamento
                : null;

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

                $params['data_agendada'] = self::getAmbulatorioAgendamentoAtual($solicitacao)->jornada->data
                    ?? $solicitacao->exameImagemAgendamento->data ?? null
                    ?? $solicitacao->exameLaboratorialAgendamento->data ?? null;

                $params['hora_agendada'] = self::getAmbulatorioAgendamentoAtual($solicitacao)->horario
                    ?? $solicitacao->exameImagemAgendamento->hora_exame ?? null
                    ?? $solicitacao->exameLaboratorialAgendamento->horario ?? null;
            }
            else {

                $params['data_agendada'] = Carbon::createFromFormat('d/m/Y', request()->data_agendada);
                $params['hora_agendada'] = request()->hora_agendada;
            }

            if ($solicitacao->regulacao_tipo_id === Tipo::INTERNO
                || ($solicitacao->regulacao_tipo_id === Tipo::AMBOS && is_null(request()->prestador_externo_id))
            ) {

                $params['prestador_interno_id'] = request()->prestador_interno_id;
            }
            else if ($solicitacao->regulacao_tipo_id === Tipo::EXTERNO
                || ($solicitacao->regulacao_tipo_id === Tipo::AMBOS && is_null(request()->prestador_interno_id))
            ) {

                $params['prestador_externo_id'] = request()->prestador_externo_id;
            }

            if ($statusTipoId === StatusTipo::REAGENDADO) {

                $params['justificativa_reagendamento'] = request()->justificativa_reagendamento;
            }
        }
        else if ($statusTipoId === StatusTipo::REALIZADO) {

            $params['posicao_municipal'] = null;
            $params['posicao_regulador'] = null;
            $params['posicao_portal'] = null;
            $params['ocupacao_executora_id'] = request()->ocupacao_executora_id;
            $params['usuario_executor_nome'] = request()->usuario_executor_nome;
        }
        else if ($statusTipoId === StatusTipo::CANCELADO) {

            $params['posicao_municipal'] = null;
            $params['posicao_regulador'] = null;
            $params['posicao_portal'] = null;
            $params['cancelado_em'] = Carbon::now();
            $params['cancelado_lotacao_id'] = self::getCurrentLotacao()->id;
            $params['justificativa_cancelamento'] = request()->justificativa_cancelamento;
        }
        else if ($statusTipoId === StatusTipo::REMARCAR) {

            $params['posicao_municipal'] = null;
            $params['posicao_regulador'] = null;
            $params['posicao_portal'] = null;
            $params['justificativa_remarcacao'] = request()->justificativa_remarcacao;
        }
        else if ($statusTipoId === StatusTipo::FALTA) {

            $params['posicao_municipal'] = null;
            $params['posicao_regulador'] = null;
            $params['posicao_portal'] = null;
            $params['justificativa_falta'] = request()->justificativa_falta;
        }
        else if ($statusTipoId === StatusTipo::REENVIADA) {

            $lotacaoSolicitante = Lotacao::findOrFail(request()->lotacao_usuario_solicitante_id);

            $params['usuario_solicitante_id'] = $lotacaoSolicitante->usuario_id;
            $params['unidade_usuario_id'] = $lotacaoSolicitante->infraestrutura->unidade_id;
            $params['infraestrutura_usuario_id'] = $lotacaoSolicitante->infraestrutura_id;
            $params['ocupacao_usuario_id'] = $lotacaoSolicitante->ocupacao_id;
            $params['lotaca_usuario_id'] = $lotacaoSolicitante->id;
            $params['cid_id'] = request()->cid_id;
            $params['ciap_id'] = request()->ciap_id;
            $params['hipotese_diagnostica_justificativa'] = request()->hipotese_diagnostica_justificativa;
            $params['observacao'] = request()->observacao;
            $params['justificativa_reenvio'] = request()->justificativa_reenvio;
        }
        else if ($statusTipoId === StatusTipo::DEVOLVIDO) {

            $params['justificativa_devolucao'] = request()->justificativa_devolucao;
        }

        return $params;
    }

    private static function updateStatusNoModuloDeAgendamento($solicitacao)
    {
        if ($agendamento = self::getAmbulatorioAgendamentoAtual($solicitacao)) {

            if ($solicitacao->status->tipo_id === StatusTipo::CANCELADO) {

                AmbulatorioAgendamentoService::cancel($agendamento->id, [
                    'is_from_regulacao' => true,
                    'motivo' => $solicitacao->justificativa_cancelamento,
                ]);
            }
            else if ($solicitacao->status->tipo_id === StatusTipo::FALTA) {

                AmbulatorioAgendamentoService::absent($agendamento->id, [
                    'is_from_regulacao' => true,
                ]);
            }
        }
        else if ($agendamento = $solicitacao->exameImagemAgendamento) {

            if ($solicitacao->status->tipo_id === StatusTipo::CANCELADO) {

                (new SmsService($agendamento->id))->cancel();

                ExameImagemAgendamentoExame::where('agendamento_id', $agendamento->id)->delete();
                $agendamento->delete();
            }
            else if ($solicitacao->status->tipo_id === StatusTipo::FALTA) {

                ExameImagemAgendamentoExame::where('agendamento_id', $agendamento->id)
                    ->update(['status_id' => ExameImagemAgendamentoStatus::FALTOU]);
            }
        }
        else if ($agendamento = $solicitacao->exameLaboratorialAgendamento) {

            if ($solicitacao->status->tipo_id === StatusTipo::CANCELADO) {

                ExameLaboratorialAgendamentoExame::where('agendamento_id', $agendamento->id)
                    ->update(['status_id' => ExameLaboratorialAgendamentoStatus::CANCELADO]);

                $exames = ExameLaboratorialAgendamentoExame::where('agendamento_id', $agendamento->id)
                    ->pluck('id');

                $exames->map(function($item) use($agendamento) {
                    $exame = ExameLaboratorialAgendamentoExame::where('id', $item)->first();
                    AgendamentoExameHistoricoService::store($exame, $agendamento, Acao::ALTERACAO);
                });
            }
            else if ($solicitacao->status->tipo_id === StatusTipo::FALTA) {

                ExameLaboratorialAgendamentoExame::where('agendamento_id', $agendamento->id)
                    ->update(['status_id' => ExameLaboratorialAgendamentoStatus::FALTOU]);

                    $exames = ExameLaboratorialAgendamentoExame::where('agendamento_id', $agendamento->id)
                    ->pluck('id');

                $exames->map(function($item) use($agendamento) {
                    $exame = ExameLaboratorialAgendamentoExame::where('id', $item)->first();
                    AgendamentoExameHistoricoService::store($exame, $agendamento, Acao::ALTERACAO);
                });
            }
        }
    }

    private static function getAmbulatorioAgendamentoAtual($solicitacao)
    {
        return $solicitacao->ambulatorioAgendamentos()
            ->whereNotIn('status_id', AmbulatorioAgendamentoService::getStatusLiberamHorario())
            ->first();
    }

    public static function getDadosAmbulatorio($id, $filter = null)
    {
        $solicitacao = Solicitacao::findOrFail($id);

        if ($solicitacao->soap_id && is_null($filter)) {
            $soapId = $solicitacao->soap_id;
            $data = [];

            $atendimentoId = DB::table('ambulatorio_atendimento_soap')
                ->where('id', $soapId)
                ->value('atendimento_id');

            $data = historicoAtendimento::show($solicitacao->paciente_id);


            $historicos = $data['form']['historico'] ?? [];
            $data['form']['historico'] = null;

            foreach ($historicos as $historico) {
                $historicoAtendimentoId = is_array($historico) ? $historico['atendimento_id'] : $historico->atendimento_id;

                if ($historicoAtendimentoId == $atendimentoId) {
                    $data['form']['historico'][] = $historico;
                }
            }

            return $data;
        } else if ($filter === false) {

            $pacienteId = $solicitacao->paciente_id;

            return historicoAtendimento::show($pacienteId);

        }

        return;
    }

    private static function getHistoricoOci($solicitacao)
    {
        if (is_null($solicitacao->acompanhamento_oci_id)) {

            return [];
        }

        return DB::table('ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS acompanhamento_oci_etapa_clinica_concluida')
            ->join(
                'cadastro_etapa_clinica AS etapa_clinica',
                'etapa_clinica.id',
                'acompanhamento_oci_etapa_clinica_concluida.etapa_clinica_id'
            )
            ->where('acompanhamento_oci_etapa_clinica_concluida.acompanhamento_oci_id', $solicitacao->acompanhamento_oci_id)
            ->select(
                'acompanhamento_oci_etapa_clinica_concluida.created_at AS data_hora',
                'etapa_clinica.nome AS etapa_clinica_nome'
            )
            ->get();
    }

    public static function getDadosOci($solicitacaoId)
    {
        $solicitacao = Solicitacao::findOrFail($solicitacaoId);

        return [
            'permite_incluir_oci' => $solicitacao->itens->first()->origem === 'exame'
                && !AcompanhamentoOci::where('paciente_id', $solicitacao->paciente_id)
                ->where('ocupacao_id', $solicitacao->ocupacao_usuario_id)
                ->whereNull('finalizado_em')
                ->exists(),
        ];
    }

    public static function getAtendimentos()
    {

        $solicitacao = Solicitacao::where('id', request()->id)->first();
        $item = SolicitacaoItem::where('solicitacao_id', request()->id)->first();


        if ($item->exame_id) {
            if ($item->exame->tipo_id === TipoExame::LABORATORIAL && !$solicitacao->prestador_externo_id) {
                $agendamentoId = AgendamentoExame::where('regulacao_solicitacao_id', $solicitacao->id)->value('id');
                $agendamentoNumero = AgendamentoExame::where('regulacao_solicitacao_id', $solicitacao->id)->value('agendamento_numero');
                $solicitacao->agendamento = [
                    'agendamento_id' => $agendamentoId,
                    'tipo_agendamento_interno_externo' => $solicitacao->tipo_agendamento_impressao_interno_externo = TipoAgendamento::INTERNO,
                    'tipo_agendamento_modulo' => $solicitacao->tipo_agendamento_modulo = TipoAgendamentoModulo::LABORATORIO,
                ];

                $request = new Request([
                    'agendamento_numero' => $agendamentoNumero
                ]);
                $impressaoExameService = new ImpressaoExameLaboratorialService();
                $solicitacao->agendamento_data = $impressaoExameService->list($request);

            } else if ($item->exame->tipo_id === TipoExame::LABORATORIAL && $solicitacao->prestador_externo_id) {

                $tipo = $solicitacao->prestadorExterno->destino->tipo->descricao ?? '';
                $logradouro = $solicitacao->prestadorExterno->destino->nome_logradouro ?? '';
                $numero = $solicitacao->prestadorExterno->destino->numero_logradouro ? $solicitacao->prestadorExterno->destino->numero_logradouro : 'S/N';
                $bairro = $solicitacao->prestadorExterno->destino->nome_bairro;
                $municipio = $solicitacao->prestadorExterno->destino->municipio->nome ?? '';
                $uf = $solicitacao->prestadorExterno->destino->municipio->estado->uf ?? '';

                $completo = "{$tipo} {$logradouro}, {$numero} - {$bairro}, {$municipio} - {$uf}";

                $solicitacao->agendamento_data = [
                    'agendamento_id' => null,
                    'tipos_agendamento_interno_externo' => TipoAgendamento::EXTERNO,
                    'tipo_agendamento_modulo' => $solicitacao->tipo_agendamento_modulo = TipoAgendamentoModulo::LABORATORIO,
                    'sistema' => self::getSistema(),
                    'exames_incluidos' => SolicitacaoItem::with('exame')
                        ->where('solicitacao_id', request()->id)
                        ->whereNotNull('exame_id')
                        ->get()
                        ->map(fn ($item) => [
                            'codigo' => $item->exame->codigo,
                            'nome'   => $item->exame->nome,
                            'observacao' => $item->exame->observacao,
                        ]),
                    'infraestrutura_solicitante' => [
                        'telefone' =>MaskUtil::getPhoneMasked($solicitacao->infraestruturaSolicitante->telefone),
                        'endereco' => [
                            'completo' =>$solicitacao->infraestruturaSolicitante->endereco->completo,
                            'cep' => MaskUtil::getCepMasked($solicitacao->infraestruturaSolicitante->endereco->logradouro->cep),
                        ],
                    ],
                    'prestador_externo' => [
                        'numero_telefone_fax' => MaskUtil::getPhoneMasked($solicitacao->prestadorExterno->destino->numero_telefone_fax),
                        'numero_telefone_comercial' => MaskUtil::getPhoneMasked($solicitacao->prestadorExterno->destino->numero_telefone_comercial),
                        'endereco' => [
                            'completo' => $completo,
                            'cep' => MaskUtil::getCepMasked($solicitacao->prestadorExterno->destino->numero_cep),
                        ],
                    ],
                ];
            } else if ($item->exame->tipo_id === TipoExame::IMAGEM && !$solicitacao->prestador_externo_id) {

                $solicitacao->agendamento = [
                    'agendamento_id' => AgendamentoExameImagem::where('regulacao_solicitacao_id', $solicitacao->id)->value('id'),
                    'tipo_agendamento_interno_externo' => $solicitacao->tipo_agendamento_impressao_interno_externo = TipoAgendamento::INTERNO,
                    'tipo_agendamento_modulo' => $solicitacao->tipo_agendamento_modulo = TipoAgendamentoModulo::IMAGEM,
                ];

                $request = new Request([
                    'id' => $solicitacao->agendamento['agendamento_id']
                ]);

                $ImpressaoExameImagemService = new ImpressaoExameImagemService();
                $solicitacao->agendamento_data = $request->id ? $ImpressaoExameImagemService->datatable($request) : [];

            } else if ($item->exame->tipo_id === TipoExame::IMAGEM && $solicitacao->prestador_externo_id) {

                $tipo = $solicitacao->prestadorExterno->destino->tipo->descricao ?? '';
                $logradouro = $solicitacao->prestadorExterno->destino->nome_logradouro ?? '';
                $numero = $solicitacao->prestadorExterno->destino->numero_logradouro ? $solicitacao->prestadorExterno->destino->numero_logradouro : 'S/N';
                $bairro = $solicitacao->prestadorExterno->destino->nome_bairro;
                $municipio = $solicitacao->prestadorExterno->destino->municipio->nome ?? '';
                $uf = $solicitacao->prestadorExterno->destino->municipio->estado->uf ?? '';

                $completo = "{$tipo} {$logradouro}, {$numero} - {$bairro}, {$municipio} - {$uf}";

                $solicitacao->agendamento_data = [
                    'agendamento_id' => null,
                    'tipos_agendamento_interno_externo' => TipoAgendamento::EXTERNO,
                    'tipo_agendamento_modulo' => $solicitacao->tipo_agendamento_modulo = TipoAgendamentoModulo::LABORATORIO,
                    'sistema' => self::getSistema(),
                    'exames_incluidos' => SolicitacaoItem::with('exame')
                        ->where('solicitacao_id', request()->id)
                        ->whereNotNull('exame_id')
                        ->get()
                        ->map(fn ($item) => [
                            'codigo' => $item->exame->codigo,
                            'nome'   => $item->exame->nome,
                            'observacao' => $item->exame->observacao,
                            'grupo' => $item->exame->grupo->nome ?? '',
                        ]),
                    'infraestrutura_solicitante' => [
                        'telefone' =>MaskUtil::getPhoneMasked($solicitacao->infraestruturaSolicitante->telefone),
                        'endereco' => [
                            'completo' =>$solicitacao->infraestruturaSolicitante->endereco->completo,
                            'cep' => MaskUtil::getCepMasked($solicitacao->infraestruturaSolicitante->endereco->logradouro->cep),
                        ],
                    ],
                    'prestador_externo' => [
                        'numero_telefone_fax' => MaskUtil::getPhoneMasked($solicitacao->prestadorExterno->destino->numero_telefone_fax),
                        'numero_telefone_comercial' => MaskUtil::getPhoneMasked($solicitacao->prestadorExterno->destino->numero_telefone_comercial),
                        'endereco' => [
                            'completo' => $completo,
                            'cep' => MaskUtil::getCepMasked($solicitacao->prestadorExterno->destino->numero_cep),
                        ],
                    ],
                ];

                // não existe impressão para agendamento externo
            }
        } else if ($item->procedimento_cirurgico_id) {
            $solicitacao->agendamento_data = [
                'agendamento_id' => AgendamentoExame::where('regulacao_solicitacao_id', $solicitacao->id)->value('id'),
                'tipo_agendamento_interno_externo' => $solicitacao->tipo_agendamento_impressao_interno_externo = TipoAgendamento::EXTERNO,
                'tipo_agendamento_modulo' => $solicitacao->tipo_agendamento_modulo = TipoAgendamentoModulo::PROCEDIMENTO_CIRURGICO,
            ];
        } else if ($item->especialidade_id) {
            if (!$solicitacao->prestador_externo_id) {
                $solicitacao->agendamento_data = [
                    'agendamento_id' => AgendamentoAmbulatorio::where('regulacao_solicitacao_id', $solicitacao->id)
                        ->whereIn('status_id',[
                            AgendamentoStatusEnum::AGENDADO,
                            AgendamentoStatusEnum::REALIZADO
                    ])
                    ->value('id'),
                    'tipo_agendamento_interno_externo' => $solicitacao->tipo_agendamento_impressao_interno_externo = TipoAgendamento::INTERNO,
                    'tipo_agendamento_modulo' => $solicitacao->tipo_agendamento_modulo = TipoAgendamentoModulo::CONSULTA,
                ];
            } else if ($solicitacao->prestador_externo_id) {

                $tipo = $solicitacao->prestadorExterno->destino->tipo->descricao ?? '';
                $logradouro = $solicitacao->prestadorExterno->destino->nome_logradouro ?? '';
                $numero = $solicitacao->prestadorExterno->destino->numero_logradouro ? $solicitacao->prestadorExterno->destino->numero_logradouro : 'S/N';
                $bairro = $solicitacao->prestadorExterno->destino->nome_bairro;
                $municipio = $solicitacao->prestadorExterno->destino->municipio->nome ?? '';
                $uf = $solicitacao->prestadorExterno->destino->municipio->estado->uf ?? '';

                $completo = "{$tipo} {$logradouro}, {$numero} - {$bairro}, {$municipio} - {$uf}";

                $solicitacao->agendamento_data = [
                    'agendamento_id' => null,
                    'tipos_agendamento_interno_externo' => TipoAgendamento::EXTERNO,
                    'tipo_agendamento_modulo' => $solicitacao->tipo_agendamento_modulo = TipoAgendamentoModulo::LABORATORIO,
                    'sistema' => self::getSistema(),
                    'exames_incluidos' => SolicitacaoItem::with('exame')
                        ->where('solicitacao_id', request()->id)
                        ->whereNotNull('exame_id')
                        ->get()
                        ->map(fn ($item) => [
                            'codigo' => $item->exame->codigo,
                            'nome'   => $item->exame->nome,
                            'observacao' => $item->exame->observacao,
                            'grupo' => $item->exame->grupo->nome ?? '',
                        ]),
                    'infraestrutura_solicitante' => [
                        'telefone' =>MaskUtil::getPhoneMasked($solicitacao->infraestruturaSolicitante->telefone),
                        'endereco' => [
                            'completo' =>$solicitacao->infraestruturaSolicitante->endereco->completo,
                            'cep' => MaskUtil::getCepMasked($solicitacao->infraestruturaSolicitante->endereco->logradouro->cep),
                        ],
                    ],
                    'prestador_externo' => [
                        'numero_telefone_fax' => MaskUtil::getPhoneMasked($solicitacao->prestadorExterno->destino->numero_telefone_fax),
                        'numero_telefone_comercial' => MaskUtil::getPhoneMasked($solicitacao->prestadorExterno->destino->numero_telefone_comercial),
                        'endereco' => [
                            'completo' => $completo,
                            'cep' => MaskUtil::getCepMasked($solicitacao->prestadorExterno->destino->numero_cep),
                        ],
                    ],
                ];
            }
        }

        return $solicitacao->agendamento_data;
    }

    private static function getSistema()
    {
        $cliente = Cliente::where('link', app('config')->get('database.default'))->firstOrFail();

        return [
            'ramo_atividade' => $cliente->sistema->ramoAtividade->nome ?? null,
            'nome_sistema' => $cliente->sistema->nome ?? null,
            'versao' => $cliente->sistema->versao ?? null,
        ];
    }

    public static function getStatusTipoDeAgendamento()
    {
        return collect([
            StatusTipo::AGENDADO,
            StatusTipo::REAGENDADO,
        ]);
    }

    private static function getStatusTiposQueSolicitantePodeEncaminhar()
    {
        return collect([
            StatusTipo::SOLICITADO,
            StatusTipo::REENVIADA,
        ]);
    }

    private static function getStatusTiposQueReguladorPodeEncaminhar()
    {
        return collect([
            StatusTipo::DEVOLVIDO,
            StatusTipo::EM_ESPERA,
            StatusTipo::AGENDADO,
            StatusTipo::REAGENDADO,
            StatusTipo::FALTA,
            StatusTipo::REALIZADO,
            StatusTipo::REMARCAR,
            StatusTipo::CANCELADO,
        ]);
    }

    public static function getStatusTiposQueFinalizamSolicitacao()
    {
        return collect([
            StatusTipo::FALTA,
            StatusTipo::REALIZADO,
            StatusTipo::CANCELADO,
        ]);
    }

    public static function getStatusTiposQueAlteramPosicoes()
    {
        return collect([
            StatusTipo::FALTA,
            StatusTipo::REALIZADO,
            StatusTipo::CANCELADO,
            StatusTipo::REMARCAR,
        ]);
    }

    public static function getStatusPermiteAlterarAntropometria()
    {
        return collect([
            StatusTipo::SOLICITADO,
            StatusTipo::DEVOLVIDO,
            StatusTipo::REENVIADA,
            StatusTipo::EM_ESPERA,
            StatusTipo::REMARCAR,
        ]);
    }

    private static function isSupervisor()
    {
        return ParametrizacaoSupervisor::where('usuario_id', self::getCurrentLotacao()->usuario_id)->exists();
    }

    public static function updateSolicitacoes()
    {
        DB::transaction(function () {
            $statusEmEspera = Status::where('tipo_id', StatusTipo::EM_ESPERA)->firstOrFail();

            self::datatable()
                ->get()
                ->each(function ($query) use ($statusEmEspera) {
                    $solicitacao = Solicitacao::findOrFail($query->id);

                    if (self::getStatusTiposQueFinalizamSolicitacao()->contains($solicitacao->status->tipo_id)) {

                        throw new CannotUpdateSolicitacaoException();
                    }

                    $solicitacao->update(['status_id' => $statusEmEspera->id]);

                    SolicitacaoService::saveHistorico($solicitacao);
                });
        });
    }

    public static function getPrintExportData()
    {
        $itens = self::datatable();

        self::setOrderBy($itens);

        $itens = $itens->get();

        $getTempoEspera = function ($solicitacao) {
            if ($solicitacao->tempo_espera === 0) {
                return 'MESMO DIA';
            }

            $dataSolicitacao = Carbon::createFromFormat('d/m/Y', $solicitacao->data);
            $dataAtual = Carbon::now();

            $diff = $dataSolicitacao->diff($dataAtual);

            $anos  = $diff->y;
            $meses = $diff->m;
            $dias = $diff->d;

            $anosText  = $anos > 0  ? ($anos > 1  ? "{$anos} anos"  : "{$anos} ano")  : null;
            $mesesText = $meses > 0 ? ($meses > 1 ? "{$meses} meses" : "{$meses} mês") : null;
            $diasText = $dias > 0 ? ($dias > 1 ? "{$dias} dias" : "{$dias} dia") : null;

            return collect([$anosText, $mesesText, $diasText])
                ->filter()
                ->implode(' e ');
        };

        $itens->each(function ($s) use ($getTempoEspera) {

            $s->dias_restantes_oci = is_null($s->dias_restantes_oci) || ((bool) $s->has_alta_oci)
                ? null : ($s->dias_restantes_oci < 0 ? 0 : $s->dias_restantes_oci);

            $s->idade = is_null($s->paciente_data_nascimento)
                ? null : AgeService::getFormattedAge(new DateTime($s->paciente_data_nascimento));

            $s->cid_descricao = MaskUtil::getCidMasked($s->cid_codigo) . " - {$s->cid_nome}";
            $s->ciap_descricao = "{$s->ciap_codigo} - {$s->ciap_descricao}";
            $s->tempo_espera = $getTempoEspera($s);
            $s->itens = explode('#', $s->itens);
            $s->telefones = collect(explode('#', $s->telefones))->map(fn ($t) => MaskUtil::getPhoneMasked($t))->join(', ');
        });

        $paciente = is_null(request()->paciente_id)
            ? null : Paciente::findOrFail(request()->paciente_id)->cidadao->nome;

        $unidadeReguladora = is_null(request()->unidade_reguladora_id)
            ? 'Todas'
            : Unidade::findOrFail(request()->unidade_reguladora_id)->nome_fantasia;

        $regulador = is_null(request()->regulador_id)
            ? 'Todos'
            : ParametrizacaoRegulador::findOrFail(request()->regulador_id)->infraestrutura->nome;

        $unidadeSolicitante = is_null(request()->unidade_solicitante_id)
            ? 'Todas'
            : Unidade::findOrFail(request()->unidade_solicitante_id)->nome_fantasia;

        $infraestruturaSolicitante = is_null(request()->infraestrutura_solicitante_id)
            ? 'Todos'
            : Infraestrutura::findOrFail(request()->infraestrutura_solicitante_id)->nome;

        $unidadeReferencia = is_null(request()->unidade_referencia_id)
            ? 'Todas'
            : Unidade::findOrFail(request()->unidade_referencia_id)->nome_fantasia;

        $usuarioSolicitante = is_null(request()->usuario_solicitante_id)
            ? 'Todos'
            : Usuario::findOrFail(request()->usuario_solicitante_id)->cidadao->nome;

        $prestador = 'Todos';

        if (request()->prestador === 'nenhum') {

            $prestador = 'Nenhum';
        }
        else if (!is_null(request()->prestador)) {

            $prestadorData = explode('#', request()->prestador);

            if ($prestadorData[0] === 'interno') {

                $prestador = ParametrizacaoPrestadorInterno::findOrFail($prestadorData[1])->infraestrutura->nome;
            }
            else if ($prestadorData[0] === 'externo') {

                $prestador = ParametrizacaoPrestadorExterno::findOrFail($prestadorData[1])->destino->descricao_destino;
            }
        }

        $quantidadeStatus = count(request()->status);
        $statusLabel = null;

        if ($quantidadeStatus > 0) {

            if ($quantidadeStatus === request()->totais_opcoes['status']) {

                $statusLabel = 'Todos';
            }
            else if ($quantidadeStatus > 1) {

                $statusLabel = "{$quantidadeStatus} selecionados";
            }
            else {

                $statusLabel = Status::findOrFail(request()->status[0])->nome;
            }
        }

        $opcaoRetiradaProtocoloAgendamento = is_null(request()->opcao_retirada_protocolo_agendamento_id)
            ? 'Todos'
            : ParametrizacaoOpcaoRetiradaProtocoloAgendamento::findOrFail(request()->opcao_retirada_protocolo_agendamento_id)->nome;

        $quantidadeGrupos = count(request()->grupos);
        $gruposLabel = null;

        if ($quantidadeGrupos > 0) {

            if ($quantidadeGrupos === request()->totais_opcoes['grupos']) {

                $gruposLabel = 'Todos';
            }
            else if ($quantidadeGrupos > 1) {

                $gruposLabel = "{$quantidadeGrupos} selecionados";
            }
            else {

                $gruposLabel = Grupo::findOrFail(request()->grupos[0])->nome;
            }
        }

        $quantidadeExames = count(request()->exames);
        $examesLabel = null;

        if ($quantidadeExames > 0) {

            if ($quantidadeExames === request()->totais_opcoes['exames']) {

                $examesLabel = 'Todos';
            }
            else if ($quantidadeExames > 1) {

                $examesLabel = "{$quantidadeExames} selecionados";
            }
            else {

                $exame = Exame::findOrFail(request()->exames[0]);

                $examesLabel = $exame->codigo
                    ? (MaskUtil::getProcedimentoMasked($exame->codigo) . " - {$exame->nome}")
                    : $exame->nome;
            }
        }

        $quantidadeProcedimentosCirurgicos = count(request()->procedimentos_cirurgicos);
        $procedimentosCirurgicosLabel = null;

        if ($quantidadeProcedimentosCirurgicos > 0) {

            if ($quantidadeProcedimentosCirurgicos === request()->totais_opcoes['procedimentos_cirurgicos']) {

                $procedimentosCirurgicosLabel = 'Todos';
            }
            else if ($quantidadeProcedimentosCirurgicos > 1) {

                $procedimentosCirurgicosLabel = "{$quantidadeProcedimentosCirurgicos} selecionados";
            }
            else {

                $procedimentoCirurgico = ProcedimentoCirurgico::findOrFail(request()->procedimentos_cirurgicos[0]);

                $procedimentosCirurgicosLabel = $procedimentoCirurgico->procedimento_codigo
                    ? (MaskUtil::getProcedimentoMasked($procedimentoCirurgico->procedimento_codigo) . " - {$procedimentoCirurgico->nome}")
                    : $procedimentoCirurgico->nome;
            }
        }

        $quantidadeEspecialidades = count(request()->especialidades);
        $especialidadesLabel = null;

        if ($quantidadeEspecialidades > 0) {

            if ($quantidadeEspecialidades === request()->totais_opcoes['especialidades']) {

                $especialidadesLabel = 'Todas';
            }
            else if ($quantidadeEspecialidades > 1) {

                $especialidadesLabel = "{$quantidadeEspecialidades} selecionadas";
            }
            else {

                $especialidade = Especialidade::findOrFail(request()->especialidades[0]);
                $especialidadesLabel = "{$especialidade->ocupacao->codigo} - {$especialidade->nome}";
            }
        }

        $quantidadePrioridades = count(request()->prioridades);
        $prioridadesLabel = null;

        if ($quantidadePrioridades > 0) {

            if ($quantidadePrioridades === request()->totais_opcoes['prioridades']) {

                $prioridadesLabel = 'Todas';
            }
            else if ($quantidadePrioridades > 1) {

                $prioridadesLabel = "{$quantidadePrioridades} selecionadas";
            }
            else {

                $prioridadesLabel = RegulacaoSolicitacaoPrioridade::findOrFail(request()->prioridades[0])->nome;
            }
        }

        $cid = null;

        if (!is_null(request()->cid_id)) {

            $cid = Cid::findOrFail(request()->cid_id);
            $cid = MaskUtil::getCidMasked($cid->codigo) . " - {$cid->nome}";
        }

        $ciap = null;

        if (!is_null(request()->ciap_id)) {

            $ciap = Ciap::findOrFail(request()->ciap_id);
            $ciap = "{$ciap->codigo} - {$ciap->descricao}";
        }

        $sexo = is_null(request()->sexo_id)
            ? 'Todos'
            : Sexo::findOrFail(request()->sexo_id)->descricao;

        $oci = is_null(request()->oci_id)
            ? 'Todos'
            : Oci::findOrFail(request()->oci_id)->nome;

        $etapaClinica = is_null(request()->etapa_clinica_id)
            ? 'Todas'
            : EtapaClinicaEnum::findOrFail(request()->etapa_clinica_id)->nome;

        return [
            'inicio' => request()->periodo['start'],
            'fim' => request()->periodo['end'],
            'movimentacaoInicio' => request()->periodo_movimentacao['start'],
            'movimentacaoFim' => request()->periodo_movimentacao['end'],
            'paciente' => $paciente,
            'idadeDe' => request()->idade_de,
            'idadeAte' => request()->idade_ate,
            'unidadesReguladorasLabel' => $unidadeReguladora,
            'reguladoresLabel' => $regulador,
            'unidadesSolicitantesLabel' => $unidadeSolicitante,
            'infraestruturasSolicitantesLabel' => $infraestruturaSolicitante,
            'unidadesReferenciasLabel' => $unidadeReferencia,
            'usuariosSolicitantesLabel' => $usuarioSolicitante,
            'prestadoresLabel' => $prestador,
            'statusLabel' => $statusLabel,
            'opcoesRetiradasProtocoloAgendamentoLabel' => $opcaoRetiradaProtocoloAgendamento,
            'gruposLabel' => $gruposLabel,
            'examesLabel' => $examesLabel,
            'procedimentosCirurgicosLabel' => $procedimentosCirurgicosLabel,
            'especialidadesLabel' => $especialidadesLabel,
            'prioridadesLabel' => $prioridadesLabel,
            'cid' => $cid,
            'ciap' => $ciap,
            'sexosLabel' => $sexo,
            'ocisLabel' => $oci,
            'etapasClinicasLabel' => $etapaClinica,
            'colunas' => collect(request()->selected_cols),
            'itens' => $itens,
        ];
    }


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

            $builder->orderByRaw('solicitacao.id');

            return;
        }

        $columns = [
            'data' => 'solicitacao.data',
            'posicao' => isset(request()->regulador_id)
                ? "IF(solicitacao.posicao_regulador IS NULL, NULL, LPAD(solicitacao.posicao_regulador, 6, '0'))"
                : "IF(solicitacao.posicao_municipal IS NULL, NULL, LPAD(solicitacao.posicao_municipal, 6, '0'))",
            'prioridade_nome' => 'prioridade.nome',
            'paciente' => "CONCAT(
                paciente_cidadao.nome,
                IF(paciente_cidadao.nome_social IS NULL,
                    '',
                    CONCAT(' (', paciente_cidadao.nome_social, ')')
                )
            )",
            'paciente_idade' => "TIMESTAMPDIFF(YEAR, paciente_cidadao.data_nascimento, CURRENT_DATE)",
            'sexo_descricao' => 'paciente_sexo.descricao',
            'data_desejada' => 'solicitacao.data_desejada',
            'data_movimentacao' => 'movimentacao.movimentado_em',
            'cid_descricao' => "CONCAT(cid.codigo, ' - ', cid.nome)",
            'ciap_descricao' => "CONCAT(ciap.codigo, ' - ', ciap.descricao)",
            'status_nome' => 'status.nome',
            'data_vencimento_oci' => "LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))",
            'dias_restantes_oci' => "TIMESTAMPDIFF(DAY,
                CURRENT_DATE,
                LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))
            )",
            'tempo_espera' => 'tempo_espera',
            'prestador_descricao' => 'prestador_descricao',
        ];

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

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