<?php

namespace App\Services\Regulacao;

use App\Enums\Regulacao\OpcaoRetiradaProtocoloAgendamento;
use App\Enums\Regulacao\ParametrizacaoDivulgacaoAba;
use App\Models\Intranet\Estado;
use App\Models\Regulacao\Parametrizacao;
use App\Models\Regulacao\ParametrizacaoDivulgacao;
use App\Models\Regulacao\ParametrizacaoDivulgacaoAba as RegulacaoParametrizacaoDivulgacaoAba;
use App\Models\Regulacao\ParametrizacaoDivulgacaoModoTempoMedio;
use App\Models\Regulacao\ParametrizacaoPrestadorExterno;
use App\Models\Regulacao\ParametrizacaoPrestadorInterno;
use App\Models\Regulacao\ParametrizacaoRegulador;
use App\Models\Regulacao\ParametrizacaoDivulgacaoRegulador;
use App\Models\Regulacao\ParametrizacaoSolicitante;
use App\Models\Regulacao\ParametrizacaoSupervisor;
use App\Services\Service;
use App\Utils\DataUtil;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;

class ParametrizacaoService extends Service
{
    public static function autocompleteGrupoExame()
    {
        $parametrizacao = Parametrizacao::first();

        return DB::table('cadastro_grupo as grupo')
            ->whereNull('grupo.deleted_at')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('parametrizacao_exame as exame')
                ->whereColumn('exame.grupo_tipo_id', 'grupo.id')
                ->whereNull('exame.deleted_at')
                ->where('exame.ativo', true)
                ->where(function ($q) use ($parametrizacao) {
                    if (!$parametrizacao->exames_nao_regulados) {
                        $q->whereNotNull('exame.regulacao_tipo_id');
                    }
                })
            )
            ->selectRaw("
                grupo.id,
                grupo.nome
            ");
    }

    public static function autocompleteExame()
    {
        $parametrizacao = Parametrizacao::first();

        return DB::query()
            ->fromSub(DB::table('cadastro_grupo as grupo')
                ->whereNull('grupo.deleted_at')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('parametrizacao_exame as exame')
                    ->whereColumn('exame.grupo_tipo_id', 'grupo.id')
                    ->whereNull('exame.deleted_at')
                    ->where('exame.ativo', true)
                    ->where(function ($q) use ($parametrizacao) {
                        if (!$parametrizacao->exames_nao_regulados) {

                            $q->whereNotNull('exame.regulacao_tipo_id');
                        }
                    })
                )
                ->selectRaw("
                    'grupo' as origem,
                    grupo.id,
                    NULL as codigo,
                    grupo.nome,
                    NULL as grupo_id,
                    NULL as grupo_nome,
                    NULL as observacoes
                ")
                ->unionAll(DB::table('parametrizacao_exame as exame')
                    ->join('cadastro_grupo as grupo', 'grupo.id', 'exame.grupo_tipo_id')
                    ->whereNull('exame.deleted_at')
                    ->where('exame.ativo', true)
                    ->where(function ($q) use ($parametrizacao) {
                        if (!$parametrizacao->exames_nao_regulados) {
                            $q->whereNotNull('exame.regulacao_tipo_id');
                        }
                    })
                    ->when(is_array(request()->not_id), fn ($q) => $q->whereNotIn('exame.id', request()->not_id))
                    ->selectRaw("
                        'exame' as origem,
                        exame.id,
                        exame.codigo,
                        exame.nome,
                        grupo.id as grupo_id,
                        grupo.nome as grupo_nome,
                        exame.observacao as observacoes
                    ")
                )
            , 'item')
            ->selectRaw("
                item.origem,
                item.id,
                item.codigo,
                item.nome,
                item.grupo_id,
                item.grupo_nome,
                item.observacoes
            ");
    }

    public static function autocompleteProcedimentoCirurgico()
    {
        if (DataUtil::isStringTrue(request()->get('only_procedimentos_cirurgicos', 'false'))) {

            return DB::table('parametrizacao_procedimento_cirurgico as procedimento_cirurgico')
                ->join('cadastro_grupo as grupo', 'grupo.id', 'procedimento_cirurgico.grupo_exame_id')
                ->where('procedimento_cirurgico.status', true)
                ->whereNotNull('procedimento_cirurgico.regulacao_tipo_id')
                ->when(is_array(request()->not_id), fn ($q) => $q->whereNotIn('procedimento_cirurgico.id', request()->not_id))
                ->selectRaw("
                    procedimento_cirurgico.id,
                    procedimento_cirurgico.procedimento_codigo as codigo,
                    procedimento_cirurgico.nome,
                    grupo.id as grupo_id,
                    grupo.nome as grupo_nome,
                    procedimento_cirurgico.observacao as observacoes
                ");
        }

        return DB::query()
            ->fromSub(DB::table('cadastro_grupo as grupo')
                ->whereNull('grupo.deleted_at')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('parametrizacao_procedimento_cirurgico as procedimento_cirurgico')
                    ->whereColumn('procedimento_cirurgico.grupo_exame_id', 'grupo.id')
                    ->where('procedimento_cirurgico.status', true)
                    ->whereNotNull('procedimento_cirurgico.regulacao_tipo_id')
                )
                ->selectRaw("
                    'grupo' as origem,
                    grupo.id,
                    NULL as codigo,
                    grupo.nome,
                    NULL as grupo_id,
                    NULL as grupo_nome,
                    NULL as observacoes
                ")
                ->unionAll(DB::table('parametrizacao_procedimento_cirurgico as procedimento_cirurgico')
                    ->join('cadastro_grupo as grupo', 'grupo.id', 'procedimento_cirurgico.grupo_exame_id')
                    ->where('procedimento_cirurgico.status', true)
                    ->whereNotNull('procedimento_cirurgico.regulacao_tipo_id')
                    ->when(is_array(request()->not_id), fn ($q) => $q->whereNotIn('procedimento_cirurgico.id', request()->not_id))
                    ->selectRaw("
                        'procedimento' as origem,
                        procedimento_cirurgico.id,
                        procedimento_cirurgico.procedimento_codigo as codigo,
                        procedimento_cirurgico.nome,
                        grupo.id as grupo_id,
                        grupo.nome as grupo_nome,
                        procedimento_cirurgico.observacao as observacoes
                    ")
                )
            , 'item')
            ->selectRaw("
                item.origem,
                item.id,
                item.codigo,
                item.nome,
                item.grupo_id,
                item.grupo_nome,
                item.observacoes
            ");
    }

    public static function autocompleteEspecialidade()
    {
        return DB::table('cadastro_especialidade as especialidade')
            ->join('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
            ->where('especialidade.ativo', true)
            ->whereNotNull('especialidade.regulacao_tipo_id')
            ->when(is_array(request()->not_id), fn ($q) => $q->whereNotIn('especialidade.id', request()->not_id))
            ->selectRaw("
                especialidade.id,
                ocupacao.codigo,
                UPPER(especialidade.nome) as nome,
                especialidade.mensagem_protocolo_agendamento as observacoes
            ");
    }

    public static function list()
    {
        $params = request()->all();

        switch (request()->listar) {

            case 'infraestruturas': {

                return self::getInfraestruturas($params);
            }
            case 'exames': {

                return self::getExames($params);
            }
            case 'procedimentos-cirurgicos': {

                return self::getProcedimentosCirurgicos($params);
            }
        }
    }

    private static function getInfraestruturas($params)
    {
        return DB::table('cadastro_infraestrutura as infraestrutura')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
            ->whereNull('infraestrutura.deleted_at')
            ->where('infraestrutura.unidade_id', $params['unidade_id'])
            ->selectRaw("
                infraestrutura.id,
                COALESCE(infraestrutura.nome, unidade.nome_fantasia) as nome
            ")
            ->orderByRaw("COALESCE(infraestrutura.nome, unidade.nome_fantasia)")
            ->get();
    }

    private static function getExames($params)
    {
        $parametrizacao = Parametrizacao::first();

        return DB::table('parametrizacao_exame as exame')
            ->join('cadastro_grupo as grupo', 'grupo.id', 'exame.grupo_tipo_id')
            ->where('exame.grupo_tipo_id', $params['grupo_id'])
            ->whereNull('exame.deleted_at')
            ->where('exame.ativo', true)
            ->where(function($q) use ($parametrizacao) {
                if (!$parametrizacao->exames_nao_regulados) {
                    $q->whereNotNull('exame.regulacao_tipo_id');
                }
            })
            ->selectRaw("
                exame.id,
                exame.codigo,
                exame.nome,
                grupo.id as grupo_id,
                grupo.nome as grupo_nome,
                exame.observacao as observacoes
            ")
            ->get();
    }

    private static function getProcedimentosCirurgicos($params)
    {
        return DB::table('parametrizacao_procedimento_cirurgico as procedimento_cirurgico')
            ->join('cadastro_grupo as grupo', 'grupo.id', 'procedimento_cirurgico.grupo_exame_id')
            ->where('procedimento_cirurgico.grupo_exame_id', $params['grupo_id'])
            ->where('procedimento_cirurgico.status', true)
            ->whereNotNull('procedimento_cirurgico.regulacao_tipo_id')
            ->when(is_array(request()->not_id), fn ($q) => $q->whereNotIn('procedimento_cirurgico.id', request()->not_id))
            ->selectRaw("
                'procedimento' as origem,
                procedimento_cirurgico.id,
                procedimento_cirurgico.procedimento_codigo as codigo,
                procedimento_cirurgico.nome,
                grupo.id as grupo_id,
                grupo.nome as grupo_nome,
                procedimento_cirurgico.observacao as observacoes
            ")
            ->get();
    }

    public static function create()
    {
        return [
            'form' => self::getFormData(),
            'model' => self::getModelData(),
        ];
    }

    private static function getFormData()
    {
        $unidades = self::getUnidades();
        $unidadesReguladas = self::getUnidadesReguladas();

        return [
            'opcoes_retirada_protocolo_agendamento' => self::getOpcoesRetiradaProtocoloAgendamento(),
            'regulador' => [
                'unidades' => $unidades,
                'infraestruturas' => [],
                'tipos' => self::getReguladorTipos(),
            ],
            'divulgacao' => [
                'unidades' => $unidadesReguladas,
                'infraestruturas' => [],
            ],
            'solicitante' => [
                'unidades' => $unidades,
                'infraestruturas' => [],
            ],
            'prestador_interno' => [
                'unidades' => self::getUnidadesPrestadoras(),
            ],
            'prestador_externo' => [
                'destinos' => self::getDestinosPrestadores(),
            ],
            'estados' => Estado::orderBy('nome')->get(['id', 'nome', 'uf'])->map(fn ($estado) => [
                'id' => $estado->id,
                'descricao' => "{$estado->nome} - {$estado->uf}"
            ]),
            'data_desejada' => [
                'unidades' => $unidades,
                'infraestruturas' => [],
            ],
            'portal_transparencia' => [
                'modos_tempo_medio' => ParametrizacaoDivulgacaoModoTempoMedio::orderBy('nome')
                    ->get(['id', 'nome'])
            ]
        ];
    }

    private static function getUnidades()
    {
        return DB::table('cadastro_unidade')
            ->whereNull('deleted_at')
            ->select('id', 'nome_fantasia')
            ->orderBy('nome_fantasia')
            ->get();
    }

    private static function getUnidadesReguladas()
    {
        return DB::table('cadastro_unidade as unidade')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.unidade_id', 'unidade.id')
            ->join('regulacao_parametrizacao_regulador as regulador', 'regulador.infraestrutura_id', 'infraestrutura.id')
            ->whereNull('unidade.deleted_at')
            ->select('unidade.id as unidade_id', 'unidade.nome_fantasia as nome_fantasia')
            ->orderBy('nome_fantasia')
            ->get();
    }

    private static function getOpcoesRetiradaProtocoloAgendamento()
    {
        return DB::table('regulacao_parametrizacao_opcao_retirada_protocolo_agendamento')
            ->orderBy('nome')
            ->select('id', 'nome')
            ->get();
    }

    private static function getReguladorTipos()
    {
        return DB::table('regulacao_parametrizacao_regulador_tipo')
            ->orderBy('nome')
            ->select('id', 'nome')
            ->get();
    }

    private static function getUnidadesPrestadoras()
    {
        $unidades = collect();

        $selectFields = "
            unidade.id as unidade_id,
            unidade.nome_fantasia as unidade_nome_fantasia,
            infraestrutura.id as infraestrutura_id,
            COALESCE(infraestrutura.nome, unidade.nome_fantasia) as infraestrutura_nome
        ";

        DB::table('ambulatorio_parametrizacao_infraestrutura as parametrizacao')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'parametrizacao.infraestrutura_id')
            ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
            ->selectRaw($selectFields)
            ->union(DB::table('exame_laboratorial_parametrizacao_unidade as parametrizacao')
                ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'parametrizacao.infraestrutura_id')
                ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
                ->where('parametrizacao.laboratorio', true)
                ->selectRaw($selectFields)
            )
            ->union(DB::table('exame_imagem_parametrizacao_unidade as parametrizacao')
                ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'parametrizacao.infraestrutura_id')
                ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
                ->where('parametrizacao.prestador', true)
                ->selectRaw($selectFields)
            )
            ->get()
            ->each(function ($parametrizacao) use ($unidades) {

                $unidade = $unidades->where('id', $parametrizacao->unidade_id)->first();

                if (is_null($unidade)) {

                    $unidade = (object) [
                        'id' => $parametrizacao->unidade_id,
                        'nome_fantasia' => $parametrizacao->unidade_nome_fantasia,
                        'infraestruturas' => collect(),
                    ];

                    $unidades->push($unidade);
                }

                $unidade->infraestruturas->push((object) [
                    'id' => $parametrizacao->infraestrutura_id,
                    'nome' => $parametrizacao->infraestrutura_nome,
                ]);
            });

        $unidades->each(fn ($u) => $u->infraestruturas = $u->infraestruturas->sortBy('nome')->values());

        return $unidades->sortBy('nome_fantasia')->values();
    }

    private static function getDestinosPrestadores()
    {
        return DB::table('transporte_paciente_destino as destino')
            ->where('destino.tipo_prestador', true)
            ->selectRaw("
                destino.id,
                destino.descricao_destino as nome
            ")
            ->orderBy('destino.descricao_destino')
            ->get();
    }

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

        return [
            'numero_solicitacao_automatico' => $parametrizacao->numero_solicitacao_automatico ?? false,
            'solicitacao_automatica_ambulatorio' => $parametrizacao->solicitacao_automatica_ambulatorio ?? false,
            'permite_agendar_fora_ordem_posicao' => $parametrizacao->permite_agendar_fora_ordem_posicao ?? false,
            'solicitacao_retroativa' => $parametrizacao->solicitacao_retroativa ?? false,
            'exames_nao_regulados' => $parametrizacao->exames_nao_regulados ?? false,
            'sempre_alterar_unidade_solicitante' => $parametrizacao->sempre_alterar_unidade_solicitante ?? false,
            'encerra_solicitacao_automaticamente_ao_encerrar_protocolo_oci' =>
                $parametrizacao->encerra_solicitacao_automaticamente_ao_encerrar_protocolo_oci ?? false,
            'exibe_assinatura_relatorio_solicitacao' => $parametrizacao->exibe_assinatura_relatorio_solicitacao ?? false,
            'opcao_retirada_protocolo_agendamento_id' => $parametrizacao->opcao_retirada_protocolo_agendamento_id
                ?? OpcaoRetiradaProtocoloAgendamento::NAO_INFORMADO,
            'mensagem_protocolo_solicitacao' => $parametrizacao->mensagem_protocolo_solicitacao ?? null,
            'mensagem_comprovante_agendamento' => $parametrizacao->mensagem_comprovante_agendamento ?? null,
            'supervisores' => DB::table('regulacao_parametrizacao_supervisor as supervisor')
                ->join('cadastro_usuario as usuario', 'usuario.id', 'supervisor.usuario_id')
                ->join('cadastro_cidadao as cidadao', 'cidadao.id', 'usuario.cidadao_id')
                ->selectRaw("
                    supervisor.id,
                    usuario.id as usuario_id,
                    cidadao.nome as usuario_nome
                ")
                ->get()
                ->map(fn ($supervisor) => [
                    'id' => $supervisor->id,
                    'usuario' => [
                        'id' => $supervisor->usuario_id,
                        'cidadao_nome' => $supervisor->usuario_nome,
                    ],
                ]),
            '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')
                ->join('regulacao_parametrizacao_regulador_tipo as tipo', 'tipo.id', 'regulador.tipo_id')
                ->selectRaw("
                    regulador.id,
                    regulador.ativo,
                    unidade.id as unidade_id,
                    unidade.nome_fantasia as unidade_nome_fantasia,
                    infraestrutura.id as infraestrutura_id,
                    COALESCE(infraestrutura.nome, unidade.nome_fantasia) as infraestrutura_nome,
                    tipo.id as tipo_id,
                    tipo.nome as tipo_nome,
                    regulador.solicitante_controla_protocolo_fechamento
                ")
                ->get()
                ->map(fn ($regulador) => [
                    'id' => $regulador->id,
                    'ativo' => (bool) $regulador->ativo,
                    'unidade_id' => $regulador->unidade_id,
                    'unidade_nome_fantasia' => $regulador->unidade_nome_fantasia,
                    'infraestrutura_id' => $regulador->infraestrutura_id,
                    'infraestrutura_nome' => $regulador->infraestrutura_nome,
                    'tipo_id' => $regulador->tipo_id,
                    'tipo_nome' => $regulador->tipo_nome,
                    'solicitante_controla_protocolo_fechamento' => (bool) $regulador->solicitante_controla_protocolo_fechamento,
                    'exames' => DB::table('regulacao_parametrizacao_regulador_exame as regulador_exame')
                        ->join('parametrizacao_exame as exame', 'exame.id', 'regulador_exame.exame_id')
                        ->join('cadastro_grupo as grupo', 'grupo.id', 'exame.grupo_tipo_id')
                        ->where('regulador_exame.regulador_id', $regulador->id)
                        ->selectRaw("
                            exame.id,
                            exame.codigo,
                            exame.nome,
                            grupo.id as grupo_id,
                            grupo.nome as grupo_nome,
                            regulador_exame.ativo,
                            regulador_exame.exige_documento_anexo
                        ")
                        ->get()
                        ->map(fn ($exame) => [
                            'id' => $exame->id,
                            'codigo' => $exame->codigo,
                            'nome' => $exame->nome,
                            'grupo_id' => $exame->grupo_id,
                            'grupo_nome' => $exame->grupo_nome,
                            'ativo' => (bool) $exame->ativo,
                            'exige_documento_anexo' => (bool) $exame->exige_documento_anexo,
                        ]),
                    'procedimentos_cirurgicos' => DB::table('regulacao_parametrizacao_regulador_procedimento_cirurgico as regulador_procedimento_cirurgico')
                        ->join(
                            'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                            'procedimento_cirurgico.id',
                            'regulador_procedimento_cirurgico.procedimento_cirurgico_id'
                        )
                        ->join('cadastro_grupo as grupo', 'grupo.id', 'procedimento_cirurgico.grupo_exame_id')
                        ->where('regulador_procedimento_cirurgico.regulador_id', $regulador->id)
                        ->selectRaw("
                            procedimento_cirurgico.id,
                            procedimento_cirurgico.procedimento_codigo as codigo,
                            procedimento_cirurgico.nome,
                            grupo.id as grupo_id,
                            grupo.nome as grupo_nome,
                            regulador_procedimento_cirurgico.ativo,
                            regulador_procedimento_cirurgico.exige_documento_anexo
                        ")
                        ->get()
                        ->map(fn ($procedimentoCirurgico) => [
                            'id' => $procedimentoCirurgico->id,
                            'codigo' => $procedimentoCirurgico->codigo,
                            'nome' => $procedimentoCirurgico->nome,
                            'grupo_id' => $procedimentoCirurgico->grupo_id,
                            'grupo_nome' => $procedimentoCirurgico->grupo_nome,
                            'ativo' => (bool) $procedimentoCirurgico->ativo,
                            'exige_documento_anexo' => (bool) $procedimentoCirurgico->exige_documento_anexo,
                        ]),
                    'especialidades' => DB::table('regulacao_parametrizacao_regulador_especialidade as regulador_especialidade')
                        ->join(
                            'cadastro_especialidade as especialidade',
                            'especialidade.id',
                            'regulador_especialidade.especialidade_id'
                        )
                        ->join('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
                        ->where('regulador_especialidade.regulador_id', $regulador->id)
                        ->selectRaw("
                            especialidade.id,
                            ocupacao.codigo,
                            especialidade.nome,
                            regulador_especialidade.ativo,
                            regulador_especialidade.exige_documento_anexo
                        ")
                        ->get()
                        ->map(fn ($especialidade) => [
                            'id' => $especialidade->id,
                            'codigo' => $especialidade->codigo,
                            'nome' => $especialidade->nome,
                            'ativo' => (bool) $especialidade->ativo,
                            'exige_documento_anexo' => (bool) $especialidade->exige_documento_anexo,
                        ]),
                ]),
            'divulgacao' => DB::table('regulacao_parametrizacao_divulgacao_regulador as regulador')
                ->join('regulacao_parametrizacao_regulador as regulacao_regulador', 'regulacao_regulador.id', 'regulador.regulacao_parametrizacao_regulador_id')
                ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'regulacao_regulador.infraestrutura_id')
                ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
                ->selectRaw("
                    regulador.id,
                    regulador.ativo,
                    unidade.id as unidade_id,
                    unidade.nome_fantasia as unidade_nome_fantasia,
                    infraestrutura.id as infraestrutura_id,
                    COALESCE(infraestrutura.nome, unidade.nome_fantasia) as infraestrutura_nome
                ")
                ->get()
                ->map(fn ($regulador) => [
                    'id' => $regulador->id,
                    'ativo' => (bool) $regulador->ativo,
                    'unidade_id' => $regulador->unidade_id,
                    'unidade_nome_fantasia' => $regulador->unidade_nome_fantasia,
                    'infraestrutura_id' => $regulador->infraestrutura_id,
                    'infraestrutura_nome' => $regulador->infraestrutura_nome,
                    'exames' => DB::table('regulacao_parametrizacao_divulgacao_regulador_exame as regulador_exame')
                        ->join('parametrizacao_exame as exame', 'exame.id', 'regulador_exame.exame_id')
                        ->join('cadastro_grupo as grupo', 'grupo.id', 'exame.grupo_tipo_id')
                        ->where('regulador_exame.regulador_id', $regulador->id)
                        ->selectRaw("
                            exame.id,
                            exame.codigo,
                            exame.nome,
                            grupo.id as grupo_id,
                            grupo.nome as grupo_nome,
                            regulador_exame.ativo
                        ")
                        ->get()
                        ->map(fn ($exame) => [
                            'id' => $exame->id,
                            'codigo' => $exame->codigo,
                            'nome' => $exame->nome,
                            'grupo_id' => $exame->grupo_id,
                            'grupo_nome' => $exame->grupo_nome,
                            'ativo' => (bool) $exame->ativo,
                        ]),
                    'procedimentos_cirurgicos' => DB::table('regulacao_parametrizacao_divulgacao_regulador_cirurgico as regulador_procedimento_cirurgico')
                        ->join(
                            'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                            'procedimento_cirurgico.id',
                            'regulador_procedimento_cirurgico.procedimento_cirurgico_id'
                        )
                        ->join('cadastro_grupo as grupo', 'grupo.id', 'procedimento_cirurgico.grupo_exame_id')
                        ->where('regulador_procedimento_cirurgico.regulador_id', $regulador->id)
                        ->selectRaw("
                            procedimento_cirurgico.id,
                            procedimento_cirurgico.procedimento_codigo as codigo,
                            procedimento_cirurgico.nome,
                            grupo.id as grupo_id,
                            grupo.nome as grupo_nome,
                            regulador_procedimento_cirurgico.ativo
                        ")
                        ->get()
                        ->map(fn ($procedimentoCirurgico) => [
                            'id' => $procedimentoCirurgico->id,
                            'codigo' => $procedimentoCirurgico->codigo,
                            'nome' => $procedimentoCirurgico->nome,
                            'grupo_id' => $procedimentoCirurgico->grupo_id,
                            'grupo_nome' => $procedimentoCirurgico->grupo_nome,
                            'ativo' => (bool) $procedimentoCirurgico->ativo,
                        ]),
                    'especialidades' => DB::table('regulacao_parametrizacao_divulgacao_regulador_especialidade as regulador_especialidade')
                        ->join(
                            'cadastro_especialidade as especialidade',
                            'especialidade.id',
                            'regulador_especialidade.especialidade_id'
                        )
                        ->join('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
                        ->where('regulador_especialidade.regulador_id', $regulador->id)
                        ->selectRaw("
                            especialidade.id,
                            ocupacao.codigo,
                            especialidade.nome,
                            regulador_especialidade.ativo
                        ")
                        ->get()
                        ->map(fn ($especialidade) => [
                            'id' => $especialidade->id,
                            'codigo' => $especialidade->codigo,
                            'nome' => $especialidade->nome,
                            'ativo' => (bool) $especialidade->ativo,
                        ]),
                ]),
            'solicitantes' => DB::table('regulacao_parametrizacao_solicitante as solicitante')
                ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'solicitante.infraestrutura_id')
                ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
                ->selectRaw("
                    solicitante.id,
                    unidade.id as unidade_id,
                    unidade.nome_fantasia as unidade_nome_fantasia,
                    infraestrutura.id as infraestrutura_id,
                    COALESCE(infraestrutura.nome, unidade.nome_fantasia) as infraestrutura_nome,
                    solicitante.is_ppi,
                    solicitante.atende_outro_municipio
                ")
                ->get()
                ->map(fn ($solicitante) => [
                    'id' => $solicitante->id,
                    'unidade_id' => $solicitante->unidade_id,
                    'unidade_nome_fantasia' => $solicitante->unidade_nome_fantasia,
                    'infraestrutura_id' => $solicitante->infraestrutura_id,
                    'infraestrutura_nome' => $solicitante->infraestrutura_nome,
                    'is_ppi' => (bool) $solicitante->is_ppi,
                    'atende_outro_municipio' => (bool) $solicitante->atende_outro_municipio,
                    'reguladores' => DB::table('regulacao_parametrizacao_solicitante_regulador as solicitante_regulador')
                        ->join('regulacao_parametrizacao_regulador as regulador', 'regulador.id', 'solicitante_regulador.regulador_id')
                        ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'regulador.infraestrutura_id')
                        ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
                        ->where('solicitante_regulador.solicitante_id', $solicitante->id)
                        ->selectRaw("
                            solicitante_regulador.id as solicitante_regulador_id,
                            regulador.id,
                            unidade.nome_fantasia as unidade_nome_fantasia,
                            infraestrutura.id as infraestrutura_id,
                            COALESCE(infraestrutura.nome, unidade.nome_fantasia) as infraestrutura_nome
                        ")
                        ->get()
                        ->map(fn ($regulador) => [
                            'id' => $regulador->id,
                            'unidade_nome_fantasia' => $regulador->unidade_nome_fantasia,
                            'infraestrutura_id' => $regulador->infraestrutura_id,
                            'infraestrutura_nome' => $regulador->infraestrutura_nome,
                            'exames' => DB::table('regulacao_parametrizacao_solicitante_regulador_exame as solicitante_regulador_exame')
                                ->join('parametrizacao_exame as exame', 'exame.id', 'solicitante_regulador_exame.exame_id')
                                ->join('cadastro_grupo as grupo', 'grupo.id', 'exame.grupo_tipo_id')
                                ->where('solicitante_regulador_exame.solicitante_regulador_id', $regulador->solicitante_regulador_id)
                                ->selectRaw("
                                    exame.id,
                                    exame.codigo,
                                    exame.nome,
                                    grupo.id as grupo_id,
                                    grupo.nome as grupo_nome
                                ")
                                ->get()
                                ->map(fn ($exame) => [
                                    'id' => $exame->id,
                                    'codigo' => $exame->codigo,
                                    'nome' => $exame->nome,
                                    'grupo_id' => $exame->grupo_id,
                                    'grupo_nome' => $exame->grupo_nome,
                                ]),
                            'procedimentos_cirurgicos' => DB::table('regulacao_parametrizacao_solicitante_regulador_proced_cirurgico as solicitante_regulador_proced_cirurgico')
                                ->join(
                                    'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                                    'procedimento_cirurgico.id',
                                    'solicitante_regulador_proced_cirurgico.procedimento_cirurgico_id'
                                )
                                ->join('cadastro_grupo as grupo', 'grupo.id', 'procedimento_cirurgico.grupo_exame_id')
                                ->where('solicitante_regulador_proced_cirurgico.solicitante_regulador_id', $regulador->solicitante_regulador_id)
                                ->selectRaw("
                                    procedimento_cirurgico.id,
                                    procedimento_cirurgico.procedimento_codigo as codigo,
                                    procedimento_cirurgico.nome,
                                    grupo.id as grupo_id,
                                    grupo.nome as grupo_nome
                                ")
                                ->get()
                                ->map(fn ($procedimentoCirurgico) => [
                                    'id' => $procedimentoCirurgico->id,
                                    'codigo' => $procedimentoCirurgico->codigo,
                                    'nome' => $procedimentoCirurgico->nome,
                                    'grupo_id' => $procedimentoCirurgico->grupo_id,
                                    'grupo_nome' => $procedimentoCirurgico->grupo_nome,
                                ]),
                            'especialidades' => DB::table('regulacao_parametrizacao_solicitante_regulador_especialidade as solicitante_regulador_especialidade')
                                ->join(
                                    'cadastro_especialidade as especialidade',
                                    'especialidade.id',
                                    'solicitante_regulador_especialidade.especialidade_id'
                                )
                                ->join('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
                                ->where('solicitante_regulador_especialidade.solicitante_regulador_id', $regulador->solicitante_regulador_id)
                                ->selectRaw("
                                    especialidade.id,
                                    ocupacao.codigo,
                                    especialidade.nome
                                ")
                                ->get()
                                ->map(fn ($especialidade) => [
                                    'id' => $especialidade->id,
                                    'codigo' => $especialidade->codigo,
                                    'nome' => $especialidade->nome,
                                ]),
                            'has_solicitacao' => DB::table('regulacao_solicitacao as solicitacao')
                                ->where('infraestrutura_solicitante_id', $solicitante->infraestrutura_id)
                                ->where('regulador_id', $regulador->id)
                                ->exists(),
                        ]),
                ]),
            'prestadores_internos' => 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')
                ->selectRaw("
                    prestador_interno.id,
                    prestador_interno.controla_protocolo_fechamento,
                    prestador_interno.ativo,
                    unidade.id as unidade_id,
                    unidade.nome_fantasia as unidade_nome_fantasia,
                    infraestrutura.id as infraestrutura_id,
                    COALESCE(infraestrutura.nome, unidade.nome_fantasia) as infraestrutura_nome
                ")
                ->get()
                ->map(fn ($prestadorInterno) => [
                    'id' => $prestadorInterno->id,
                    'controla_protocolo_fechamento' => (bool) $prestadorInterno->controla_protocolo_fechamento,
                    'ativo' => (bool) $prestadorInterno->ativo,
                    'unidade_id' => $prestadorInterno->unidade_id,
                    'unidade_nome_fantasia' => $prestadorInterno->unidade_nome_fantasia,
                    'infraestrutura_id' => $prestadorInterno->infraestrutura_id,
                    'infraestrutura_nome' => $prestadorInterno->infraestrutura_nome,
                    'exames' => DB::table('regulacao_parametrizacao_prestador_interno_exame as prestador_interno_exame')
                        ->join('parametrizacao_exame as exame', 'exame.id', 'prestador_interno_exame.exame_id')
                        ->join('cadastro_grupo as grupo', 'grupo.id', 'exame.grupo_tipo_id')
                        ->where('prestador_interno_exame.prestador_interno_id', $prestadorInterno->id)
                        ->selectRaw("
                            exame.id,
                            exame.codigo,
                            exame.nome,
                            grupo.id as grupo_id,
                            grupo.nome as grupo_nome,
                            prestador_interno_exame.ativo,
                            prestador_interno_exame.observacoes
                        ")
                        ->get()
                        ->map(fn ($exame) => [
                            'id' => $exame->id,
                            'codigo' => $exame->codigo,
                            'nome' => $exame->nome,
                            'grupo_id' => $exame->grupo_id,
                            'grupo_nome' => $exame->grupo_nome,
                            'ativo' => (bool) $exame->ativo,
                            'observacoes' => $exame->observacoes
                        ]),
                    'procedimentos_cirurgicos' => DB::table('regulacao_parametrizacao_prestador_interno_proced_cirurgico as prestador_interno_proced_cirurgico')
                        ->join(
                            'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                            'procedimento_cirurgico.id',
                            'prestador_interno_proced_cirurgico.procedimento_cirurgico_id'
                        )
                        ->join('cadastro_grupo as grupo', 'grupo.id', 'procedimento_cirurgico.grupo_exame_id')
                        ->where('prestador_interno_proced_cirurgico.prestador_interno_id', $prestadorInterno->id)
                        ->selectRaw("
                            procedimento_cirurgico.id,
                            procedimento_cirurgico.procedimento_codigo as codigo,
                            procedimento_cirurgico.nome,
                            grupo.id as grupo_id,
                            grupo.nome as grupo_nome,
                            prestador_interno_proced_cirurgico.ativo,
                            prestador_interno_proced_cirurgico.observacoes
                        ")
                        ->get()
                        ->map(fn ($procedimentoCirurgico) => [
                            'id' => $procedimentoCirurgico->id,
                            'codigo' => $procedimentoCirurgico->codigo,
                            'nome' => $procedimentoCirurgico->nome,
                            'grupo_id' => $procedimentoCirurgico->grupo_id,
                            'grupo_nome' => $procedimentoCirurgico->grupo_nome,
                            'ativo' => (bool) $procedimentoCirurgico->ativo,
                            'observacoes' => $procedimentoCirurgico->observacoes
                        ]),
                    'especialidades' => DB::table('regulacao_parametrizacao_prestador_interno_especialidade as prestador_interno_especialidade')
                        ->join(
                            'cadastro_especialidade as especialidade',
                            'especialidade.id',
                            'prestador_interno_especialidade.especialidade_id'
                        )
                        ->join('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
                        ->where('prestador_interno_especialidade.prestador_interno_id', $prestadorInterno->id)
                        ->selectRaw("
                            especialidade.id,
                            ocupacao.codigo,
                            especialidade.nome,
                            prestador_interno_especialidade.ativo,
                            prestador_interno_especialidade.observacoes
                        ")
                        ->get()
                        ->map(fn ($especialidade) => [
                            'id' => $especialidade->id,
                            'codigo' => $especialidade->codigo,
                            'nome' => $especialidade->nome,
                            'ativo' => (bool) $especialidade->ativo,
                            'observacoes' => $especialidade->observacoes
                        ]),
                ]),
            'prestadores_externos' => DB::table('regulacao_parametrizacao_prestador_externo as prestador_externo')
                ->join('transporte_paciente_destino as destino', 'destino.id', 'prestador_externo.destino_id')
                ->whereNull('deleted_at')
                ->selectRaw("
                    prestador_externo.id,
                    prestador_externo.ativo,
                    destino.id as destino_id,
                    destino.descricao_destino as destino_nome
                ")
                ->get()
                ->map(fn ($prestadorExterno) => [
                    'id' => $prestadorExterno->id,
                    'ativo' => (bool) $prestadorExterno->ativo,
                    'destino_id' => $prestadorExterno->destino_id,
                    'destino_nome' => $prestadorExterno->destino_nome,
                    'exames' => DB::table('regulacao_parametrizacao_prestador_externo_exame as prestador_externo_exame')
                        ->join('parametrizacao_exame as exame', 'exame.id', 'prestador_externo_exame.exame_id')
                        ->join('cadastro_grupo as grupo', 'grupo.id', 'exame.grupo_tipo_id')
                        ->where('prestador_externo_exame.prestador_externo_id', $prestadorExterno->id)
                        ->selectRaw("
                            exame.id,
                            exame.codigo,
                            exame.nome,
                            grupo.id as grupo_id,
                            grupo.nome as grupo_nome,
                            prestador_externo_exame.ativo,
                            prestador_externo_exame.observacoes
                        ")
                        ->get()
                        ->map(fn ($exame) => [
                            'id' => $exame->id,
                            'codigo' => $exame->codigo,
                            'nome' => $exame->nome,
                            'grupo_id' => $exame->grupo_id,
                            'grupo_nome' => $exame->grupo_nome,
                            'ativo' => (bool) $exame->ativo,
                            'observacoes' => $exame->observacoes
                        ]),
                    'procedimentos_cirurgicos' => DB::table('regulacao_parametrizacao_prestador_externo_proced_cirurgico as prestador_externo_proced_cirurgico')
                        ->join(
                            'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                            'procedimento_cirurgico.id',
                            'prestador_externo_proced_cirurgico.procedimento_cirurgico_id'
                        )
                        ->join('cadastro_grupo as grupo', 'grupo.id', 'procedimento_cirurgico.grupo_exame_id')
                        ->where('prestador_externo_proced_cirurgico.prestador_externo_id', $prestadorExterno->id)
                        ->selectRaw("
                            procedimento_cirurgico.id,
                            procedimento_cirurgico.procedimento_codigo as codigo,
                            procedimento_cirurgico.nome,
                            grupo.id as grupo_id,
                            grupo.nome as grupo_nome,
                            prestador_externo_proced_cirurgico.ativo,
                            prestador_externo_proced_cirurgico.observacoes
                        ")
                        ->get()
                        ->map(fn ($procedimentoCirurgico) => [
                            'id' => $procedimentoCirurgico->id,
                            'codigo' => $procedimentoCirurgico->codigo,
                            'nome' => $procedimentoCirurgico->nome,
                            'grupo_id' => $procedimentoCirurgico->grupo_id,
                            'grupo_nome' => $procedimentoCirurgico->grupo_nome,
                            'ativo' => (bool) $procedimentoCirurgico->ativo,
                            'observacoes' => $procedimentoCirurgico->observacoes
                        ]),
                    'especialidades' => DB::table('regulacao_parametrizacao_prestador_externo_especialidade as prestador_externo_especialidade')
                        ->join(
                            'cadastro_especialidade as especialidade',
                            'especialidade.id',
                            'prestador_externo_especialidade.especialidade_id'
                        )
                        ->join('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
                        ->where('prestador_externo_especialidade.prestador_externo_id', $prestadorExterno->id)
                        ->selectRaw("
                            especialidade.id,
                            ocupacao.codigo,
                            especialidade.nome,
                            prestador_externo_especialidade.ativo,
                            prestador_externo_especialidade.observacoes
                        ")
                        ->get()
                        ->map(fn ($especialidade) => [
                            'id' => $especialidade->id,
                            'codigo' => $especialidade->codigo,
                            'nome' => $especialidade->nome,
                            'ativo' => (bool) $especialidade->ativo,
                            'observacoes' => $especialidade->observacoes
                        ]),
                ]),
            '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,
            'obriga_data_desejada' => $parametrizacao->obriga_data_desejada ?? false,
            'data_desejada_grupos_exames' => is_null($parametrizacao)
                ? []
                : DB::table('regulacao_parametrizacao_data_desejada_grupo_exame as data_desejada_grupo_exame')
                    ->join('cadastro_grupo as grupo', 'grupo.id', 'data_desejada_grupo_exame.grupo_id')
                    ->where('data_desejada_grupo_exame.parametrizacao_id', $parametrizacao->id)
                    ->selectRaw("
                        grupo.id,
                        grupo.nome
                    ")
                    ->get()
                    ->map(fn ($grupo) => [
                        'id' => $grupo->id,
                        'nome' => $grupo->nome,
                    ]),
            'data_desejada_procedimentos_cirurgicos' => is_null($parametrizacao)
                ? []
                : DB::table('regulacao_parametrizacao_data_desejada_procedimento_cirurgico as data_desejada_procedimento_cirurgico')
                    ->join(
                        'parametrizacao_procedimento_cirurgico as procedimento_cirurgico',
                        'procedimento_cirurgico.id',
                        'data_desejada_procedimento_cirurgico.procedimento_cirurgico_id'
                    )
                    ->where('data_desejada_procedimento_cirurgico.parametrizacao_id', $parametrizacao->id)
                    ->selectRaw("
                        procedimento_cirurgico.id,
                        procedimento_cirurgico.procedimento_codigo as codigo,
                        procedimento_cirurgico.nome
                    ")
                    ->get()
                    ->map(fn ($procedimentoCirurgico) => [
                        'id' => $procedimentoCirurgico->id,
                        'codigo' => $procedimentoCirurgico->codigo,
                        'nome' => $procedimentoCirurgico->nome,
                    ]),
            'data_desejada_especialidades' => is_null($parametrizacao)
                ? []
                : DB::table('regulacao_parametrizacao_data_desejada_especialidade as data_desejada_especialidade')
                    ->join('cadastro_especialidade as especialidade', 'especialidade.id', 'data_desejada_especialidade.especialidade_id')
                    ->join('sigtap.ocupacao', 'ocupacao.id', 'especialidade.ocupacao_id')
                    ->where('data_desejada_especialidade.parametrizacao_id', $parametrizacao->id)
                    ->selectRaw("
                        especialidade.id,
                        ocupacao.codigo,
                        especialidade.nome
                    ")
                    ->get()
                    ->map(fn ($especialidade) => [
                        'id' => $especialidade->id,
                        'codigo' => $especialidade->codigo,
                        'nome' => $especialidade->nome,
                    ]),
            'data_desejada_infraestruturas' => is_null($parametrizacao)
                ? []
                : DB::table('regulacao_parametrizacao_data_desejada_infraestrutura as data_desejada_infraestrutura')
                    ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'data_desejada_infraestrutura.infraestrutura_id')
                    ->join('cadastro_unidade as unidade', 'unidade.id', 'infraestrutura.unidade_id')
                    ->where('data_desejada_infraestrutura.parametrizacao_id', $parametrizacao->id)
                    ->selectRaw("
                        infraestrutura.id,
                        COALESCE(infraestrutura.nome, unidade.nome_fantasia) as nome,
                        unidade.nome_fantasia as unidade_nome_fantasia
                    ")
                    ->get()
                    ->map(fn ($infraestrutura) => [
                        'id' => $infraestrutura->id,
                        'nome' => $infraestrutura->nome,
                        'unidade_nome_fantasia' => $infraestrutura->unidade_nome_fantasia,
                    ]),
            'portal_transparencia' => self::getPortalTransparenciaModelData(),
        ];
    }

    private static function getPortalTransparenciaModelData()
    {
        $getColunas = function ($abaId) {
            return DB::table('regulacao_parametrizacao_divulgacao_coluna as coluna')
                ->join('regulacao_parametrizacao_divulgacao_aba_coluna as aba_coluna', 'aba_coluna.coluna_id', 'coluna.id')
                ->where('aba_coluna.aba_id', $abaId)
                ->select(
                    'coluna.id',
                    'coluna.nome',
                    'aba_coluna.visivel'
                )
                ->orderBy('coluna.nome')
                ->get()
                ->map(fn ($coluna) => (object) [
                    'id' => $coluna->id,
                    'nome' => $coluna->nome,
                    'visivel' => (bool) $coluna->visivel,
                ]);
        };

        $getStatusTipos = function ($abaId) {
            return DB::table('regulacao_status_tipo as status_tipo')
                ->join('regulacao_parametrizacao_divulgacao_aba_status_tipo as aba_status_tipo', 'aba_status_tipo.status_tipo_id', 'status_tipo.id')
                ->where('aba_status_tipo.aba_id', $abaId)
                ->select(
                    'status_tipo.id',
                    'status_tipo.nome',
                    'aba_status_tipo.visivel'
                )
                ->orderBy('status_tipo.nome')
                ->get()
                ->map(fn ($statusTipo) => (object) [
                    'id' => $statusTipo->id,
                    'nome' => $statusTipo->nome,
                    'visivel' => (bool) $statusTipo->visivel,
                ]);
        };

        $parametrizacao = ParametrizacaoDivulgacao::first();

        return [
            'abas' => [
                'solicitacao_espera' => [
                    'colunas' => $getColunas(ParametrizacaoDivulgacaoAba::SOLICITACOES_EM_ESPERA),
                    'status_tipos' => $getStatusTipos(ParametrizacaoDivulgacaoAba::SOLICITACOES_EM_ESPERA),
                ],
                'solicitacao_atendida' => [
                    'colunas' => $getColunas(ParametrizacaoDivulgacaoAba::SOLICITACOES_ATENDIDAS),
                    'status_tipos' => $getStatusTipos(ParametrizacaoDivulgacaoAba::SOLICITACOES_ATENDIDAS),
                ],
            ],
            'modo_tempo_medio_id' => $parametrizacao->modo_tempo_medio_id ?? null,
        ];
    }

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

        $parametrizacao = Parametrizacao::firstOrNew();

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

            $supervisores = collect(request()->supervisores);
            $reguladores = collect(request()->reguladores);
            $solicitantes = collect(request()->solicitantes);
            $prestadoresInternos = collect(request()->prestadores_internos);
            $prestadoresExternos = collect(request()->prestadores_externos);
            $divulgacao = collect(request()->divulgacao);

            $parametrizacao->fill(request()->only([
                'numero_solicitacao_automatico',
                'solicitacao_automatica_ambulatorio',
                'permite_agendar_fora_ordem_posicao',
                'opcao_retirada_protocolo_agendamento_id',
                'mensagem_protocolo_solicitacao',
                'mensagem_comprovante_agendamento',
                'exibe_protocolo_cross',
                'obriga_protocolo_cross',
                'usuario_registro_estado_id',
                'obriga_data_desejada',
                'solicitacao_retroativa',
                'exames_nao_regulados',
                'sempre_alterar_unidade_solicitante',
                'encerra_solicitacao_automaticamente_ao_encerrar_protocolo_oci',
                'exibe_assinatura_relatorio_solicitacao',
            ]));

            $parametrizacao->save();

            $parametrizacao->dataDesejadaGruposExames()->sync(request()->data_desejada_grupos_exames);
            $parametrizacao->dataDesejadaProcedimentosCirurgicos()->sync(request()->data_desejada_procedimentos_cirurgicos);
            $parametrizacao->dataDesejadaEspecialidades()->sync(request()->data_desejada_especialidades);
            $parametrizacao->dataDesejadaInfraestruturas()->sync(request()->data_desejada_infraestruturas);

            $supervisoresIds = self::saveSupervisores($supervisores);
            $reguladoresIds = self::saveReguladores($reguladores);
            $divulgacaoIds = self::saveDivulgacaoReguladores($divulgacao);
            $solicitantesIds = self::saveSolicitantes($solicitantes);
            $prestadoresInternosIds = self::savePrestadoresInternos($prestadoresInternos);
            $prestadoresExternosIds = self::savePrestadoresExternos($prestadoresExternos);

            ParametrizacaoSupervisor::whereNotIn('id', $supervisoresIds)->delete();
            ParametrizacaoRegulador::whereNotIn('id', $reguladoresIds)->delete();
            ParametrizacaoDivulgacaoRegulador::whereNotIn('id', $divulgacaoIds)->delete();
            ParametrizacaoSolicitante::whereNotIn('id', $solicitantesIds)->delete();
            ParametrizacaoPrestadorInterno::whereNotIn('id', $prestadoresInternosIds)->delete();
            ParametrizacaoPrestadorExterno::whereNotIn('id', $prestadoresExternosIds)->delete();

            self::savePortalTransparencia();
        });

        return $parametrizacao->fresh();
    }

    private static function saveSupervisores($supervisores)
    {
        $ids = collect();

        $supervisores->each(function ($params) use ($ids) {

            $supervisor = ParametrizacaoSupervisor::updateOrCreate(['id' => $params['id']], $params);

            $ids->push($supervisor->id);
        });

        return $ids;
    }

    private static function saveDivulgacaoReguladores($reguladores)
    {
        $ids = collect();

        $reguladores->each(function ($params) use ($ids) {

            $reguladorParams = DB::table('regulacao_parametrizacao_regulador')
                    ->where('infraestrutura_id', $params['infraestrutura_id'])
                    ->first();

            $regulador = ParametrizacaoDivulgacaoRegulador::updateOrCreate(['id' => $params['id']], array_merge($params, [
                'regulacao_parametrizacao_regulador_id' => $reguladorParams->id ?? null
            ]));

            DB::table('regulacao_parametrizacao_divulgacao_regulador_exame')
                ->where('regulador_id', $regulador->id)
                ->whereNotIn('exame_id', array_keys(self::getItemsWithIdOnKey($params['exames'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['exames']) as $key => $value) {
                $existsReguladorExame = DB::table('regulacao_parametrizacao_divulgacao_regulador_exame')
                    ->where('regulador_id', $regulador->id)
                    ->where('exame_id', $key)
                    ->exists();

                if (!$existsReguladorExame) {
                    $regulador->exames()->attach($key, [
                        'ativo' => $value['ativo'],
                    ]);
                }

                DB::table('regulacao_parametrizacao_divulgacao_regulador_exame')
                    ->where('regulador_id', $regulador->id)
                    ->where('exame_id', $key)
                    ->update([
                        'ativo' => $value['ativo'],
                    ]);
            }

            DB::table('regulacao_parametrizacao_divulgacao_regulador_cirurgico')
                ->where('regulador_id', $regulador->id)
                ->whereNotIn('procedimento_cirurgico_id', array_keys(self::getItemsWithIdOnKey($params['procedimentos_cirurgicos'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['procedimentos_cirurgicos']) as $key => $value) {
                $existsReguladorProcedimentoCirurgico = DB::table('regulacao_parametrizacao_divulgacao_regulador_cirurgico')
                    ->where('regulador_id', $regulador->id)
                    ->where('procedimento_cirurgico_id', $key)
                    ->exists();

                if (!$existsReguladorProcedimentoCirurgico) {
                    $regulador->procedimentosCirurgicos()->attach($key, [
                        'ativo' => $value['ativo'],
                    ]);
                }

                DB::table('regulacao_parametrizacao_divulgacao_regulador_cirurgico')
                    ->where('regulador_id', $regulador->id)
                    ->where('procedimento_cirurgico_id', $key)
                    ->update([
                        'ativo' => $value['ativo'],
                    ]);
            }

            DB::table('regulacao_parametrizacao_divulgacao_regulador_especialidade')
                ->where('regulador_id', $regulador->id)
                ->whereNotIn('especialidade_id', array_keys(self::getItemsWithIdOnKey($params['especialidades'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['especialidades']) as $key => $value) {
                $existsReguladorEspecialidade = DB::table('regulacao_parametrizacao_divulgacao_regulador_especialidade')
                    ->where('regulador_id', $regulador->id)
                    ->where('especialidade_id', $key)
                    ->exists();

                if (!$existsReguladorEspecialidade) {
                    $regulador->especialidades()->attach($key, [
                        'ativo' => $value['ativo'],
                    ]);
                }

                DB::table('regulacao_parametrizacao_divulgacao_regulador_especialidade')
                    ->where('regulador_id', $regulador->id)
                    ->where('especialidade_id', $key)
                    ->update([
                        'ativo' => $value['ativo'],
                    ]);
            }

            $ids->push($regulador->id);
        });

        return $ids;
    }

    private static function saveReguladores($reguladores)
    {
        $ids = collect();

        $reguladores->each(function ($params) use ($ids) {

            $regulador = ParametrizacaoRegulador::updateOrCreate(['id' => $params['id']], $params);

            DB::table('regulacao_parametrizacao_regulador_exame')
                ->where('regulador_id', $regulador->id)
                ->whereNotIn('exame_id', array_keys(self::getItemsWithIdOnKey($params['exames'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['exames']) as $key => $value) {
                $existsReguladorExame = DB::table('regulacao_parametrizacao_regulador_exame')
                    ->where('regulador_id', $regulador->id)
                    ->where('exame_id', $key)
                    ->exists();

                if (!$existsReguladorExame) {
                    $regulador->exames()->attach($key, [
                        'ativo' => $value['ativo'],
                        'exige_documento_anexo' => $value['exige_documento_anexo']
                    ]);
                }

                DB::table('regulacao_parametrizacao_regulador_exame')
                    ->where('regulador_id', $regulador->id)
                    ->where('exame_id', $key)
                    ->update([
                        'ativo' => $value['ativo'],
                        'exige_documento_anexo' => $value['exige_documento_anexo']
                    ]);
            }

            DB::table('regulacao_parametrizacao_regulador_procedimento_cirurgico')
                ->where('regulador_id', $regulador->id)
                ->whereNotIn('procedimento_cirurgico_id', array_keys(self::getItemsWithIdOnKey($params['procedimentos_cirurgicos'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['procedimentos_cirurgicos']) as $key => $value) {
                $existsReguladorProcedimentoCirurgico = DB::table('regulacao_parametrizacao_regulador_procedimento_cirurgico')
                    ->where('regulador_id', $regulador->id)
                    ->where('procedimento_cirurgico_id', $key)
                    ->exists();

                if (!$existsReguladorProcedimentoCirurgico) {
                    $regulador->procedimentosCirurgicos()->attach($key, [
                        'ativo' => $value['ativo'],
                        'exige_documento_anexo' => $value['exige_documento_anexo']
                    ]);
                }

                DB::table('regulacao_parametrizacao_regulador_procedimento_cirurgico')
                    ->where('regulador_id', $regulador->id)
                    ->where('procedimento_cirurgico_id', $key)
                    ->update([
                        'ativo' => $value['ativo'],
                        'exige_documento_anexo' => $value['exige_documento_anexo']
                    ]);
            }

            DB::table('regulacao_parametrizacao_regulador_especialidade')
                ->where('regulador_id', $regulador->id)
                ->whereNotIn('especialidade_id', array_keys(self::getItemsWithIdOnKey($params['especialidades'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['especialidades']) as $key => $value) {
                $existsReguladorEspecialidade = DB::table('regulacao_parametrizacao_regulador_especialidade')
                    ->where('regulador_id', $regulador->id)
                    ->where('especialidade_id', $key)
                    ->exists();

                if (!$existsReguladorEspecialidade) {
                    $regulador->especialidades()->attach($key, [
                        'ativo' => $value['ativo'],
                        'exige_documento_anexo' => $value['exige_documento_anexo']
                    ]);
                }

                DB::table('regulacao_parametrizacao_regulador_especialidade')
                    ->where('regulador_id', $regulador->id)
                    ->where('especialidade_id', $key)
                    ->update([
                        'ativo' => $value['ativo'],
                        'exige_documento_anexo' => $value['exige_documento_anexo']
                    ]);
            }

            $ids->push($regulador->id);
        });

        return $ids;
    }

    private static function saveSolicitantes($solicitantes)
    {
        $ids = collect();

        $solicitantes->each(function ($params) use ($ids) {

            $solicitante = ParametrizacaoSolicitante::updateOrCreate(['id' => $params['id']], $params);

            $solicitantesReguladoresIds = collect();

            collect($params['reguladores'])->each(function ($params) use ($solicitante, $solicitantesReguladoresIds) {

                if (is_null($params['id'])) {

                    $params['id'] = ParametrizacaoRegulador::where('infraestrutura_id', $params['infraestrutura_id'])
                        ->first('id')
                        ->id;
                }

                $solicitanteRegulador = $solicitante->solicitanteReguladores()->updateOrCreate(
                    ['regulador_id' => $params['id']]
                );

                $solicitanteRegulador->exames()->sync($params['exames']);
                $solicitanteRegulador->procedimentosCirurgicos()->sync($params['procedimentos_cirurgicos']);
                $solicitanteRegulador->especialidades()->sync($params['especialidades']);

                $solicitantesReguladoresIds->push($solicitanteRegulador->id);
            });

            $solicitante->solicitanteReguladores()->whereNotIn('id', $solicitantesReguladoresIds)->delete();

            $ids->push($solicitante->id);
        });

        return $ids;
    }

    private static function savePrestadoresInternos($prestadoresInternos)
    {
        $ids = collect();

        $prestadoresInternos->each(function ($params) use ($ids) {

            $prestador = ParametrizacaoPrestadorInterno::updateOrCreate(['id' => $params['id']], $params);

            $prestador->exames()->sync(self::getItemsWithIdOnKey($params['exames']));
            $prestador->procedimentosCirurgicos()->sync(self::getItemsWithIdOnKey($params['procedimentos_cirurgicos']));
            $prestador->especialidades()->sync(self::getItemsWithIdOnKey($params['especialidades']));

            $ids->push($prestador->id);
        });

        return $ids;
    }

    private static function savePrestadoresExternos($prestadoresExternos)
    {
        $ids = collect();

        $prestadoresExternos->each(function ($params) use ($ids) {

            $prestador = ParametrizacaoPrestadorExterno::updateOrCreate(['id' => $params['id']], $params);

            DB::table('regulacao_parametrizacao_prestador_externo_exame')
                ->where('prestador_externo_id', $prestador->id)
                ->whereNotIn('exame_id', array_keys(self::getItemsWithIdOnKey($params['exames'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['exames']) as $key => $value) {
                $existsPrestadorExternoExame = DB::table('regulacao_parametrizacao_prestador_externo_exame')
                    ->where('prestador_externo_id', $prestador->id)
                    ->where('exame_id', $key)
                    ->exists();

                if (!$existsPrestadorExternoExame) {
                    $prestador->exames()->attach($key, [
                        'ativo' => $value['ativo'],
                        'observacoes' => $value['observacoes'],
                    ]);
                }
            }

            DB::table('regulacao_parametrizacao_prestador_externo_proced_cirurgico')
                ->where('prestador_externo_id', $prestador->id)
                ->whereNotIn('procedimento_cirurgico_id', array_keys(self::getItemsWithIdOnKey($params['procedimentos_cirurgicos'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['procedimentos_cirurgicos']) as $key => $value) {
                $existsPrestadorExternoProcedimentoCirurgico = DB::table('regulacao_parametrizacao_prestador_externo_proced_cirurgico')
                    ->where('prestador_externo_id', $prestador->id)
                    ->where('procedimento_cirurgico_id', $key)
                    ->exists();

                if (!$existsPrestadorExternoProcedimentoCirurgico) {
                    $prestador->procedimentosCirurgicos()->attach($key, [
                        'ativo' => $value['ativo'],
                        'observacoes' => $value['observacoes'],
                    ]);
                }
            }

            DB::table('regulacao_parametrizacao_prestador_externo_especialidade')
                ->where('prestador_externo_id', $prestador->id)
                ->whereNotIn('especialidade_id', array_keys(self::getItemsWithIdOnKey($params['especialidades'])))
                ->delete();

            foreach (self::getItemsWithIdOnKey($params['especialidades']) as $key => $value) {
                $existsPrestadorExternoEspecialidade = DB::table('regulacao_parametrizacao_prestador_externo_especialidade')
                    ->where('prestador_externo_id', $prestador->id)
                    ->where('especialidade_id', $key)
                    ->exists();

                if (!$existsPrestadorExternoEspecialidade) {
                    $prestador->especialidades()->attach($key, [
                        'ativo' => $value['ativo'],
                        'observacoes' => $value['observacoes'],
                    ]);
                }
            }

            $ids->push($prestador->id);
        });

        return $ids;
    }

    private static function getItemsWithIdOnKey($items)
    {
        $newItems = [];

        foreach ($items as $item) {

            $id = $item['id'];

            unset($item['id']);

            $newItems[$id] = $item;
        }

        return $newItems;
    }

    private static function savePortalTransparencia()
    {
        ParametrizacaoDivulgacao::updateOrCreate([], [
            'modo_tempo_medio_id' => request()->portal_transparencia['modo_tempo_medio_id']
        ]);

        self::saveAbaSolicitacaoEspera();
        self::saveAbaSolicitacaoAtendida();
    }

    private static function saveAbaSolicitacaoEspera()
    {
        $aba = RegulacaoParametrizacaoDivulgacaoAba::findOrFail(ParametrizacaoDivulgacaoAba::SOLICITACOES_EM_ESPERA);

        $colunas = [];

        foreach (request()->portal_transparencia['abas']['solicitacao_espera']['colunas'] as $coluna) {
            $colunas[$coluna['id']] = ['visivel' => $coluna['visivel']];
        }

        $aba->colunas()->sync($colunas);

        $statusTipos = [];

        foreach (request()->portal_transparencia['abas']['solicitacao_espera']['status_tipos'] as $statusTipo) {
            $statusTipos[$statusTipo['id']] = ['visivel' => $statusTipo['visivel']];
        }

        $aba->statusTipos()->sync($statusTipos);
    }

    private static function saveAbaSolicitacaoAtendida()
    {
        $aba = RegulacaoParametrizacaoDivulgacaoAba::findOrFail(ParametrizacaoDivulgacaoAba::SOLICITACOES_ATENDIDAS);

        $colunas = [];

        foreach (request()->portal_transparencia['abas']['solicitacao_atendida']['colunas'] as $coluna) {
            $colunas[$coluna['id']] = ['visivel' => $coluna['visivel']];
        }

        $aba->colunas()->sync($colunas);

        $statusTipos = [];

        foreach (request()->portal_transparencia['abas']['solicitacao_atendida']['status_tipos'] as $statusTipo) {
            $statusTipos[$statusTipo['id']] = ['visivel' => $statusTipo['visivel']];
        }

        $aba->statusTipos()->sync($statusTipos);
    }

    public static function validate()
    {
        Validator::make(request()->all(), [
            'numero_solicitacao_automatico' => ['required', 'boolean'],
            'solicitacao_automatica_ambulatorio' => ['required', 'boolean'],
            'permite_agendar_fora_ordem_posicao' => ['required', 'boolean'],
            'opcao_retirada_protocolo_agendamento_id' => ['required', 'integer'],
            'mensagem_protocolo_solicitacao' => ['nullable', 'string', 'max:500'],
            'mensagem_comprovante_agendamento' => ['nullable', 'string', 'max:500'],
            'exibe_protocolo_cross' => ['required', 'boolean'],
            'obriga_protocolo_cross' => ['required', 'boolean'],
            'usuario_registro_estado_id' => ['nullable', 'integer'],
            'obriga_data_desejada' => ['required', 'boolean'],
            'data_desejada_grupos_exames' => ['present', 'array'],
            'data_desejada_grupos_exames.*' => ['required', 'integer'],
            'data_desejada_procedimentos_cirurgicos' => ['present', 'array'],
            'data_desejada_procedimentos_cirurgicos.*' => ['required', 'integer'],
            'data_desejada_especialidades' => ['present', 'array'],
            'data_desejada_especialidades.*' => ['required', 'integer'],
            'data_desejada_infraestruturas' => ['present', 'array'],
            'data_desejada_infraestruturas.*' => ['required', 'integer'],
            'solicitacao_retroativa' => ['required', 'boolean'],
            'exames_nao_regulados' => ['required', 'boolean'],
            'sempre_alterar_unidade_solicitante' => ['required', 'boolean'],
            'encerra_solicitacao_automaticamente_ao_encerrar_protocolo_oci' => ['required', 'boolean'],
            'exibe_assinatura_relatorio_solicitacao' => ['required', 'boolean'],
        ])->validate();

        self::getSupervisorValidations();
        self::getReguladorValidations();
        self::getSolicitanteValidations();
        self::getPrestadorInternoValidations();
        self::getPrestadorExternoValidations();
        self::getPortalTransparenciaValidations();
    }

    private static function getSupervisorValidations()
    {
        Validator::make(request()->all(), [
            'supervisores' => ['present', 'array'],
            'supervisores.*.id' => ['nullable', 'integer'],
            'supervisores.*.usuario_id' => ['required', 'integer'],
        ])->validate();
    }

    private static function getReguladorValidations()
    {
        Validator::make(request()->all(), [
            'reguladores' => ['present', 'array'],
            'reguladores.*.id' => ['nullable', 'integer'],
            'reguladores.*.ativo' => ['required', 'boolean'],
            'reguladores.*.infraestrutura_id' => ['required', 'integer'],
            'reguladores.*.tipo_id' => ['required', 'integer'],
        ])->validate();

        foreach (request()->all()['reguladores'] as $regulador) {
            Validator::make($regulador, [
                'exames' => ['present', 'array'],
                'exames.*.id' => ['required', 'integer'],
                'exames.*.ativo' => ['required', 'boolean'],
                'exames.*.observacoes' => ['nullable', 'string', 'max:1000'],
                'procedimentos_cirurgicos' => ['present', 'array'],
                'procedimentos_cirurgicos.*.id' => ['required', 'integer'],
                'procedimentos_cirurgicos.*.ativo' => ['required', 'boolean'],
                'especialidades' => ['present', 'array'],
                'especialidades.*.id' => ['required', 'integer'],
                'especialidades.*.ativo' => ['required', 'boolean'],
                'reguladores.*.exames.*.exige_documento_anexo' => ['required', 'boolean'],
                'reguladores.*.procedimentos_cirurgicos.*.exige_documento_anexo' => ['required', 'boolean'],
                'reguladores.*.especialidades.*.exige_documento_anexo' => ['required', 'boolean'],


            ])->validate();
        }
    }

    private static function getSolicitanteValidations()
    {
        Validator::make(request()->all(), [
            'solicitantes' => ['present', 'array'],
            'solicitantes.*.id' => ['nullable', 'integer'],
            'solicitantes.*.infraestrutura_id' => ['required', 'integer'],
            'solicitantes.*.is_ppi' => ['required', 'boolean'],
            'solicitantes.*.atende_outro_municipio' => ['required', 'boolean'],
        ])->validate();

        foreach (request()->all()['solicitantes'] as $solicitante) {
            Validator::make($solicitante, [
                'reguladores' => ['present', 'array'],
                'reguladores.*.id' => ['nullable', 'integer'],
                'reguladores.*.infraestrutura_id' => ['required', 'integer'],
                'reguladores.*.exames' => ['present', 'array'],
                'reguladores.*.exames.*' => ['required', 'integer'],
                'reguladores.*.procedimentos_cirurgicos' => ['present', 'array'],
                'reguladores.*.procedimentos_cirurgicos.*' => ['required', 'integer'],
                'reguladores.*.especialidades' => ['present', 'array'],
                'reguladores.*.especialidades.*' => ['required', 'integer'],
            ])->validate();
        }
    }

    private static function getPrestadorInternoValidations()
    {
        Validator::make(request()->all(), [
            'prestadores_internos' => ['present', 'array'],
            'prestadores_internos.*.id' => ['nullable', 'integer'],
            'prestadores_internos.*.controla_protocolo_fechamento' => ['required', 'boolean'],
            'prestadores_internos.*.ativo' => ['required', 'boolean'],
            'prestadores_internos.*.infraestrutura_id' => ['required', 'integer'],
        ])->validate();

        foreach (request()->all()['prestadores_internos'] as $prestador) {
            Validator::make($prestador, [
                'exames' => ['present', 'array'],
                'exames.*.id' => ['required', 'integer'],
                'exames.*.ativo' => ['required', 'boolean'],
                'exames.*.observacoes' => ['nullable', 'string', 'max:1000'],
                'procedimentos_cirurgicos' => ['present', 'array'],
                'procedimentos_cirurgicos.*.id' => ['required', 'integer'],
                'procedimentos_cirurgicos.*.ativo' => ['required', 'boolean'],
                'procedimentos_cirurgicos.*.observacoes' => ['nullable', 'string', 'max:1000'],
                'especialidades' => ['present', 'array'],
                'especialidades.*.id' => ['required', 'integer'],
                'especialidades.*.ativo' => ['required', 'boolean'],
                'especialidades.*.observacoes' => ['nullable', 'string', 'max:1000'],
            ])->validate();
        }
    }

    private static function getPrestadorExternoValidations()
    {
        Validator::make(request()->all(), [
            'prestadores_externos' => ['present', 'array'],
            'prestadores_externos.*.id' => ['nullable', 'integer'],
            'prestadores_externos.*.ativo' => ['required', 'boolean'],
            'prestadores_externos.*.destino_id' => ['required', 'integer'],
        ])->validate();

        foreach (request()->all()['prestadores_externos'] as $prestador) {
            Validator::make($prestador, [
                'exames' => ['present', 'array'],
                'exames.*.id' => ['required', 'integer'],
                'exames.*.ativo' => ['required', 'boolean'],
                'exames.*.observacoes' => ['nullable', 'string', 'max:1000'],
                'procedimentos_cirurgicos' => ['present', 'array'],
                'procedimentos_cirurgicos.*.id' => ['required', 'integer'],
                'procedimentos_cirurgicos.*.ativo' => ['required', 'boolean'],
                'procedimentos_cirurgicos.*.observacoes' => ['nullable', 'string', 'max:1000'],
                'especialidades' => ['present', 'array'],
                'especialidades.*.id' => ['required', 'integer'],
                'especialidades.*.ativo' => ['required', 'boolean'],
                'especialidades.*.observacoes' => ['nullable', 'string', 'max:1000'],
            ])->validate();
        }
    }

    private static function getPortalTransparenciaValidations()
    {
        Validator::make(request()->all(), [
            'portal_transparencia' => ['required', 'array'],
            'portal_transparencia.modo_tempo_medio_id' => ['nullable', 'integer'],
            'portal_transparencia.abas' => ['required', 'array'],
            'portal_transparencia.abas.solicitacao_espera' => ['required', 'array'],
            'portal_transparencia.abas.solicitacao_espera.colunas' => ['required', 'array'],
            'portal_transparencia.abas.solicitacao_espera.colunas.*.id' => ['required', 'integer'],
            'portal_transparencia.abas.solicitacao_espera.colunas.*.visivel' => ['required', 'boolean'],
            'portal_transparencia.abas.solicitacao_espera.status_tipos' => ['required', 'array'],
            'portal_transparencia.abas.solicitacao_espera.status_tipos.*.id' => ['required', 'integer'],
            'portal_transparencia.abas.solicitacao_espera.status_tipos.*.visivel' => ['required', 'boolean'],
            'portal_transparencia.abas.solicitacao_atendida' => ['required', 'array'],
            'portal_transparencia.abas.solicitacao_atendida.colunas' => ['required', 'array'],
            'portal_transparencia.abas.solicitacao_atendida.colunas.*.id' => ['required', 'integer'],
            'portal_transparencia.abas.solicitacao_atendida.colunas.*.visivel' => ['required', 'boolean'],
            'portal_transparencia.abas.solicitacao_atendida.status_tipos' => ['required', 'array'],
            'portal_transparencia.abas.solicitacao_atendida.status_tipos.*.id' => ['required', 'integer'],
            'portal_transparencia.abas.solicitacao_atendida.status_tipos.*.visivel' => ['required', 'boolean'],
        ])->validate();
    }
}