<?php

namespace App\Services\Ambulatorio;

use App\Models\Administracao\Funcionalidade;
use App\Models\Ambulatorio\ParametrizacaoAgendamento;
use App\Models\Ambulatorio\ParametrizacaoAssinaturaEletronica;
use App\Models\Ambulatorio\ParametrizacaoAtendimento;
use App\Models\Ambulatorio\ParametrizacaoInfraestrutura;
use App\Models\Ambulatorio\ParametrizacaoInfraestruturaAgendadora;
use App\Models\Ambulatorio\ParametrizacaoInfraestruturaEspecialidade;
use App\Models\Ambulatorio\ParametrizacaoInfraestruturaEspecialidadeProcedimento;
use App\Models\Ambulatorio\ParametrizacaoInfraestruturaOcupacao;
use App\Models\Ambulatorio\ParametrizacaoIntegracaoAplicativo;
use App\Models\Ambulatorio\ParametrizacaoSigilo;
use App\Models\Ambulatorio\ParametrizacaoSigiloInfraestrutura;
use App\Models\Ambulatorio\ParametrizacaoSigiloOcupacao;
use App\Models\Ambulatorio\Servico;
use App\Models\Ambulatorio\SigiloTipo;
use App\Models\Cadastro\Especialidade;
use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Sigtap\Ocupacao;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;

class ParametrizacaoService extends Service
{
    public static function create()
    {
        return [
            'form' => self::getDadosForm(),
            'model' => self::getDadosModel(),
        ];
    }

    private static function getDadosForm()
    {
        return [
            'infraestrutura' => [
                'unidades' => self::getInfraestruturaUnidades(),
                'infraestruturas' => [],
                'servicos' => [],
                'atencao_basica_funcionalidades' => collect([
                    self::getAtencaoBasicaFuncionalidade('avaliacao'),
                    self::getAtencaoBasicaFuncionalidade('atendimento-domiciliar'),
                    self::getAtencaoBasicaFuncionalidade('atendimento-individual'),
                    self::getAtencaoBasicaFuncionalidade('atendimento-odontologico'),
                    self::getAtencaoBasicaFuncionalidade('marcador-consumo-alimentar'),
                    self::getAtencaoBasicaFuncionalidade('procedimento'),
                ]),
                'assinaturas' => ParametrizacaoAssinaturaEletronica::orderBy('descricao')->get()
            ],
            'sigilo' => [
                'unidades' => self::getSigiloUnidades(),
                'infraestruturas' => [],
                'sigilo_tipos' => self::getSigiloTipos(),
            ],
        ];
    }

    private static function getAtencaoBasicaFuncionalidade($identificador)
    {
        return Funcionalidade::whereHas('modulo', fn ($q) => $q
                ->where('identificador', 'atencao-basica')
            )
            ->where('identificador', $identificador)
            ->first(['id', 'nome']);
    }

    public static function list()
    {
        switch (request()->origem) {

            case 'infraestrutura': {

                return self::getDadosListInfraestrutura();
            }
            case 'sigilo': {

                return self::getDadosListSigilo();
            }
        }
    }

    private static function getDadosListInfraestrutura()
    {
        $params = (object) request()->all();

        switch (request()->listar) {

            case 'infraestruturas': {

                return self::getInfraestruturaInfraestruturas($params);
            }
            case 'servicos': {

                return self::getInfraestruturaServicos();
            }
        }
    }

    private static function getDadosListSigilo()
    {
        $params = (object) request()->all();

        switch (request()->listar) {

            case 'infraestruturas': {

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

    private static function getInfraestruturaUnidades()
    {
        return Unidade::orderBy('nome_fantasia')
            ->whereHas('infraestruturas')
            ->get(['id', 'nome_fantasia']);
    }

    private static function getInfraestruturaInfraestruturas($params)
    {
        return Infraestrutura::setEagerLoads([])
            ->where('unidade_id', $params->unidade_id)
            ->get(['id', 'nome', 'principal', 'unidade_id'])
            ->map(fn ($infraestrutura) => [
                'id' => $infraestrutura->id,
                'nome' => $infraestrutura->nome,
            ])
            ->sortBy('nome')
            ->values();
    }

    private static function getInfraestruturaServicos()
    {
        return Servico::orderBy('nome')->get(['id', 'nome']);
    }

    private static function getSigiloUnidades()
    {
        return Unidade::orderBy('nome_fantasia')
            ->whereHas('infraestruturas')
            ->get(['id', 'nome_fantasia']);
    }

    private static function getSigiloInfraestruturas($params)
    {
        return Infraestrutura::setEagerLoads([])
            ->where('unidade_id', $params->unidade_id)
            ->get(['id', 'nome', 'principal', 'unidade_id'])
            ->map(fn ($infraestrutura) => [
                'id' => $infraestrutura->id,
                'nome' => $infraestrutura->nome,
            ])
            ->sortBy('nome')
            ->values();
    }

    private static function getSigiloTipos()
    {
        return SigiloTipo::orderBy('id')->get(['id', 'nome']);
    }

    private static function getDadosModel()
    {
        return [
            'infraestrutura' => self::getModelInfraestrutura(),
            'agendamento' => self::getModelAgendamento(),
            'integracaoAplicativo' => self::getModelIntegracaoAplicativo(),
            'atendimento' => self::getModelAtendimento(),
            'sigilo' => self::getModelSigilo(),
        ];
    }

    private static function getModelInfraestrutura()
    {
        return [
            'infraestruturas' => self::getInfraestruturasParametrizadas(),
        ];
    }

    private static function getInfraestruturasParametrizadas()
    {
        return ParametrizacaoInfraestrutura::get(['id', 'infraestrutura_id', 'envia_sms', 'fatura_procedimento_raas'])
            ->map(function ($parametrizacao) {

                $infraestrutura = $parametrizacao->infraestrutura()
                    ->setEagerLoads([])
                    ->first(['id', 'nome', 'principal', 'unidade_id']);

                $unidade = $infraestrutura->unidade()
                    ->setEagerLoads([])
                    ->first(['nome_fantasia']);

                return [
                    'id' => $infraestrutura->id,
                    'deleted' => false,
                    'nome' => $infraestrutura->nome,
                    'unidade_nome_fantasia' => $unidade->nome_fantasia,
                    'envia_sms' => $parametrizacao->envia_sms,
                    'fatura_procedimento_raas' => $parametrizacao->fatura_procedimento_raas,
                    'ocupacoes' => $parametrizacao->ocupacoes
                        ->map(fn ($parametrizacao) => [
                            'id' => $parametrizacao->ocupacao_id,
                            'codigo' => $parametrizacao->ocupacao->codigo,
                            'nome' => $parametrizacao->ocupacao->nome,
                            'pos_consulta' => $parametrizacao->pos_consulta,
                            'permite_atendimento_enfermagem' => $parametrizacao->permite_atendimento_enfermagem,
                            'atencao_basica_funcionalidades' => $parametrizacao->fichasAtb->pluck('id'),
                        ]),
                    'especialidades' => $parametrizacao->especialidades
                        ->map(fn ($parametrizacao) => [
                            'id' => $parametrizacao->especialidade_id,
                            'nome' => $parametrizacao->especialidade->nome,
                            'ocupacao_id' => $parametrizacao->especialidade->ocupacao->id,
                            'ocupacao_codigo' => $parametrizacao->especialidade->ocupacao->codigo,
                            'avisa_falta_quantidade' => $parametrizacao->avisa_falta_quantidade ?? null,
                            'avisa_falta_dias' => $parametrizacao->avisa_falta_dias ?? null,
                            'quantidade_dias_retorno' => $parametrizacao->quantidade_dias_retorno ?? null,
                            'demanda_espontanea_observa_vaga_atendimento' => $parametrizacao->demanda_espontanea_observa_vaga_atendimento ?? false,
                            'is_regulado' => $parametrizacao->especialidade->is_regulado ?? false,
                            'procedimentos' => $parametrizacao->procedimentos
                                ->map(fn ($parametrizacao) => [
                                    'codigo' => $parametrizacao->codigo,
                                    'nome' => $parametrizacao->procedimento->nome,
                                ]),
                        ]),
                    'infraestruturas_agendadoras' => $parametrizacao->infraestruturasAgendadoras
                        ->map(fn ($parametrizacao) => [
                            'id' => $parametrizacao->infraestrutura_id,
                            'nome' => $parametrizacao->infraestrutura->nome,
                            'unidade_nome_fantasia' => $parametrizacao->infraestrutura->unidade->nome_fantasia,
                        ]),
                    'sms' => [
                        'dia_antecedencia' => $parametrizacao->sms->dia_antecedencia ?? null,
                        'periodo_envio' => [
                            'start' => is_null($parametrizacao->sms->envio_de ?? null)
                                ? null : (new Carbon($parametrizacao->sms->envio_de))->format('d/m/Y'),
                            'end' => is_null($parametrizacao->sms->envio_ate ?? null)
                                ? null : (new Carbon($parametrizacao->sms->envio_ate))->format('d/m/Y'),
                        ],
                        'especialidades' => ($parametrizacao->sms->especialidades ?? collect())
                            ->map(fn ($especialidade) => [
                                'id' => $especialidade->id,
                                'nome' => $especialidade->nome,
                                'ocupacao_codigo' => $especialidade->ocupacao->codigo,
                            ]),
                    ],
                    'servicos' => $parametrizacao->servicos()
                        ->orderBy('nome')
                        ->get(['id', 'nome'])
                        ->map(fn ($servico) => [
                            'id' => $servico->id,
                            'nome' => $servico->nome,
                        ]),
                    'assinaturas' => $parametrizacao->assinaturas
                        ->pluck('parametrizacao_assinatura_eletronica_id')
                        ->toArray(),
                ];
            });
    }

    private static function getModelAgendamento()
    {
        $agendamento = ParametrizacaoAgendamento::first();

        return [
            'avisa_cns_provisorio' => $agendamento->avisa_cns_provisorio ?? false,
            'avisa_paciente_outra_unidade' => $agendamento->avisa_paciente_outra_unidade ?? false,
            'bloqueia_paciente_temporario' => $agendamento->bloqueia_paciente_temporario ?? false,
            'obriga_motivo_agendamento_excedente' => $agendamento->obriga_motivo_agendamento_excedente ?? false,
            'permite_agendar_mesma_especialidade' => $agendamento->permite_agendar_mesma_especialidade ?? false,
            'gerenciar_tratamento' => $agendamento->gerenciar_tratamento ?? false,
        ];
    }

    private static function getModelIntegracaoAplicativo()
    {
        $integracao = ParametrizacaoIntegracaoAplicativo::first();

        return [
            'habilita_integracao_conectasus_cidadao' =>
                $integracao->habilita_integracao_conectasus_cidadao ?? false,
            'habilita_integracao_aplicativo_feridas' =>
                $integracao->habilita_integracao_aplicativo_feridas ?? false,
        ];
    }

    private static function getModelAtendimento()
    {
        $atendimento = ParametrizacaoAtendimento::first();

        return [
            'exibe_mensagem_atendimento_retroativo_nao_finalizado' =>
                $atendimento->exibe_mensagem_atendimento_retroativo_nao_finalizado ?? false,
            'exibe_box_exame_laboratorial_solicitado' =>
                $atendimento->exibe_box_exame_laboratorial_solicitado ?? false,
            'receita_nao_padronizada_justificativa_obrigatoria' =>
                $atendimento->receita_nao_padronizada_justificativa_obrigatoria ?? false,
            'modelo_impressao_sadt' =>
                $atendimento->modelo_impressao_sadt ?? 'padrao',
            'modelo_impressao_apac' =>
                $atendimento->modelo_impressao_apac ?? 'padrao',
            'visualizar_remume' =>
                $atendimento->visualizar_remume ?? false,
            'visualizar_estoque' =>
                $atendimento->visualizar_estoque ?? false,
            'cadastro_prescricoes' =>
                $atendimento->cadastro_prescricoes ?? false,
            'permite_exame_laboratorial_repetido' =>
                $atendimento->permite_exame_laboratorial_repetido ?? false,
            'permite_exame_imagem_repetido' =>
                $atendimento->permite_exame_imagem_repetido ?? false,
            'permite_encaminhar_repetido' =>
                $atendimento->permite_encaminhar_repetido ?? false,
            'permite_prescricao_repetida' =>
                $atendimento->permite_prescricao_repetida ?? false,
            'prescricao_limite_dias' =>
                $atendimento->prescricao_limite_dias ?? null,
        ];
    }

    private static function getModelSigilo()
    {
        return [
            'sigilos' => self::getSigilosParametrizados(),
        ];
    }

    private static function getSigilosParametrizados()
    {
        return ParametrizacaoSigilo::get(['id', 'ocupacao_id', 'infraestrutura_id', 'sigilo_tipo_id'])
            ->map(function ($parametrizacao) {
                $ocupacao = $parametrizacao->ocupacao()
                    ->setEagerLoads([])
                    ->first(['id', 'codigo', 'nome']);

                $infraestrutura = $parametrizacao->infraestrutura()
                    ->setEagerLoads([])
                    ->first(['id', 'nome', 'principal', 'unidade_id']);

                $unidade = $infraestrutura ? $infraestrutura->unidade()
                    ->setEagerLoads([])
                    ->first(['nome_fantasia']) : null;

                $sigiloTipo = $parametrizacao->sigiloTipo()
                    ->setEagerLoads([])
                    ->first(['id', 'nome']);

                return [
                    'ocupacao' => [
                        'id' => $ocupacao->id,
                        'codigo' => $ocupacao->codigo,
                        'nome' => $ocupacao->nome,
                    ],
                    'unidade_nome_fantasia' => $unidade->nome_fantasia ?? null,
                    'infraestrutura_id' => $infraestrutura->id ?? null,
                    'infraestrutura_nome' => $infraestrutura->nome ?? null,
                    'sigilo_tipo_id' => $sigiloTipo->id,
                    'sigilo_tipo_nome' => $sigiloTipo->nome,
                    'infraestruturas' => $parametrizacao->infraestruturas
                        ->map(fn ($parametrizacao) => [
                            'id' => $parametrizacao->infraestrutura_id,
                            'nome' => $parametrizacao->infraestrutura->nome,
                            'unidade_nome_fantasia' => $parametrizacao->infraestrutura->unidade->nome_fantasia,
                        ]),
                    'ocupacoes' => $parametrizacao->ocupacoes
                        ->map(fn ($parametrizacao) => [
                            'id' => $parametrizacao->ocupacao_id,
                            'codigo' => $parametrizacao->ocupacao->codigo,
                            'nome' => $parametrizacao->ocupacao->nome,
                        ]),
                    'deleted' => false,
                ];
            });
    }

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

        DB::transaction(function () {

            self::saveInfraestrutura();
            self::saveAgendamento();
            self::saveIntegracaoAplicativo();
            self::saveAtendimento();
            self::saveSigilo();
        });
    }

    private static function saveInfraestrutura()
    {
        $infraestruturas = collect(request()->infraestrutura['infraestruturas']);

        ParametrizacaoInfraestrutura::whereIn('infraestrutura_id',
            $infraestruturas->where('deleted', true)->pluck('id')
        )->delete();

        $infraestruturas->where('deleted', false)->each(function ($parametrizacaoData) {

            $parametrizacao = ParametrizacaoInfraestrutura::updateOrCreate(
                ['infraestrutura_id' => $parametrizacaoData['id']],
                [
                    'envia_sms' => $parametrizacaoData['envia_sms'],
                    'fatura_procedimento_raas' => $parametrizacaoData['fatura_procedimento_raas'],
                ]
            );

            self::saveInfraestruturaOcupacoes($parametrizacao, $parametrizacaoData);
            self::saveInfraestruturaEspecialidades($parametrizacao, $parametrizacaoData);
            self::saveInfraestruturaAssinaturas($parametrizacao, $parametrizacaoData);
            self::saveInfraestruturaInfraestruturasAgendadoras($parametrizacao, $parametrizacaoData);
            self::saveInfraestruturaSms($parametrizacao, $parametrizacaoData);

            $parametrizacao->servicos()->sync($parametrizacaoData['servicos']);
        });
    }

    private static function saveInfraestruturaOcupacoes($parametrizacao, $parametrizacaoData)
    {
        $ocupacoes = collect($parametrizacaoData['ocupacoes']);

        $ocupacaoIds = ParametrizacaoInfraestruturaOcupacao::where('parametrizacao_infraestrutura_id', $parametrizacao->id)
            ->whereNotIn('ocupacao_id', $ocupacoes->pluck('id'))
            ->pluck('id');

        DB::table('ambulatorio_parametrizacao_infraestrutura_ocupacao_ficha_atb')
            ->whereIn('parametrizacao_infraestrutura_ocupacao_id', $ocupacaoIds)
            ->delete();

        ParametrizacaoInfraestruturaOcupacao::where('parametrizacao_infraestrutura_id', $parametrizacao->id)
            ->whereNotIn('ocupacao_id', $ocupacoes->pluck('id'))
            ->delete();

        $ocupacoes->each(function ($data) use ($parametrizacao) {

            $ocupacao = $parametrizacao->ocupacoes()->updateOrCreate(
                ['ocupacao_id' => $data['id']],
                $data
            );

            $ocupacao->fichasAtb()->sync($data['atencao_basica_funcionalidades']);
        });
    }

    private static function saveInfraestruturaEspecialidades($parametrizacao, $parametrizacaoData)
    {
        $especialidades = collect($parametrizacaoData['especialidades']);

        ParametrizacaoInfraestruturaEspecialidade::where('parametrizacao_infraestrutura_id', $parametrizacao->id)
            ->whereNotIn('especialidade_id', $especialidades->pluck('id'))
            ->delete();

        $especialidades->each(function ($data) use ($parametrizacao) {

            $parametrizacaoEspecialidade = $parametrizacao->especialidades()->updateOrCreate(
                ['especialidade_id' => $data['id']],
                $data
            );

            $procedimentos = collect($data['procedimentos']);

            ParametrizacaoInfraestruturaEspecialidadeProcedimento::where('parametrizacao_infraestrutura_especialidade_id', $parametrizacaoEspecialidade->id)
                ->whereNotIn('codigo', $procedimentos->pluck('codigo'))
                ->delete();

            $procedimentos->each(function ($data) use ($parametrizacaoEspecialidade) {

                $parametrizacaoEspecialidade->procedimentos()->updateOrCreate(
                    ['codigo' => $data['codigo']],
                );
            });
        });
    }

    private static function saveInfraestruturaAssinaturas($parametrizacao, $parametrizacaoData)
    {

        $assinaturas = collect($parametrizacaoData['assinaturas']);

        $parametrizacao->assinaturas()->delete();

        foreach ($assinaturas as $id) {
            $parametrizacao->assinaturas()->updateOrCreate(
                ['parametrizacao_assinatura_eletronica_id' => $id],
                ['parametrizacao_infraestrutura_id' => $parametrizacao->id]
            );
        }
    }

    private static function saveInfraestruturaInfraestruturasAgendadoras($parametrizacao, $parametrizacaoData)
    {
        $infraestruturasAgendadoras = collect($parametrizacaoData['infraestruturas_agendadoras']);

        ParametrizacaoInfraestruturaAgendadora::where('parametrizacao_infraestrutura_id', $parametrizacao->id)
            ->whereNotIn('infraestrutura_id', $infraestruturasAgendadoras->pluck('id'))
            ->delete();

        $infraestruturasAgendadoras->each(function ($data) use ($parametrizacao) {

            $parametrizacao->infraestruturasAgendadoras()->updateOrCreate(
                ['infraestrutura_id' => $data['id']],
                $data
            );
        });
    }

    private static function saveInfraestruturaSms($parametrizacao, $parametrizacaoData)
    {
        if (is_null($parametrizacaoData['sms']['dia_antecedencia'])) {

            if (!is_null($parametrizacao->sms)) {

                $parametrizacao->sms->delete();
            }
        }
        else {

            $smsData = [
                'dia_antecedencia' => $parametrizacaoData['sms']['dia_antecedencia'],
                'envio_de' => is_null($parametrizacaoData['sms']['envio_de'])
                    ? null
                    : Carbon::createFromFormat('d/m/Y', $parametrizacaoData['sms']['envio_de'])
                        ->format('Y-m-d'),
                'envio_ate' => is_null($parametrizacaoData['sms']['envio_ate'])
                    ? null
                    : Carbon::createFromFormat('d/m/Y', $parametrizacaoData['sms']['envio_ate'])
                        ->format('Y-m-d'),
            ];

            $sms = $parametrizacao->sms;

            if (is_null($sms)) {

                $sms = $parametrizacao->sms()->create($smsData);
            }
            else {

                $sms->update($smsData);
            }

            $sms->especialidades()->sync($parametrizacaoData['sms']['especialidades']);
        }
    }

    private static function saveAgendamento()
    {
        $agendamento = ParametrizacaoAgendamento::first();

        if (is_null($agendamento)) {

            ParametrizacaoAgendamento::create(request()->agendamento);
        }
        else {

            $agendamento->update(request()->agendamento);
        }
    }

    private static function saveIntegracaoAplicativo()
    {
        $integracao = ParametrizacaoIntegracaoAplicativo::first();

        if (is_null($integracao)) {

            ParametrizacaoIntegracaoAplicativo::create(request()->integracao_aplicativo);
        }
        else {

            $integracao->update(request()->integracao_aplicativo);
        }
    }

    private static function saveAtendimento()
    {
        $atendimento = ParametrizacaoAtendimento::first();

        if (is_null($atendimento)) {

            ParametrizacaoAtendimento::create(request()->atendimento);
        }
        else {

            $atendimento->update(request()->atendimento);
        }
    }

    private static function saveSigilo()
    {
        $sigilos = collect(request()->sigilo['sigilos']);

        foreach ($sigilos as $sigilo) {
            if ($sigilo['deleted'] === true) {
                ParametrizacaoSigilo::where('ocupacao_id', $sigilo['ocupacao_id'])
                    ->when($sigilo['infraestrutura_id'], fn ($q, $infraestruturaId) => $q->where('infraestrutura_id', $infraestruturaId))
                    ->delete();
            }
        }

        $sigilos->where('deleted', false)->each(function ($parametrizacaoData) {
            $parametrizacao = ParametrizacaoSigilo::updateOrCreate(
                [
                    'ocupacao_id' => $parametrizacaoData['ocupacao_id'],
                    'infraestrutura_id' => $parametrizacaoData['infraestrutura_id'],
                ],
                ['sigilo_tipo_id' => $parametrizacaoData['sigilo_tipo_id']]
            );

            self::saveSigiloOcupacoes($parametrizacao, $parametrizacaoData);
            self::saveSigiloInfraestruturas($parametrizacao, $parametrizacaoData);
        });
    }

    private static function saveSigiloOcupacoes($parametrizacao, $parametrizacaoData)
    {
        $ocupacoes = collect($parametrizacaoData['ocupacoes']);

        ParametrizacaoSigiloOcupacao::where('parametrizacao_sigilo_id', $parametrizacao->id)
            ->whereNotIn('ocupacao_id', $ocupacoes->pluck('id'))
            ->delete();

        $ocupacoes->each(function ($data) use ($parametrizacao) {
            $parametrizacao->ocupacoes()->updateOrCreate(['ocupacao_id' => $data['id']]);
        });
    }

    private static function saveSigiloInfraestruturas($parametrizacao, $parametrizacaoData)
    {
        $infraestruturas = collect($parametrizacaoData['infraestruturas']);

        ParametrizacaoSigiloInfraestrutura::where('parametrizacao_sigilo_id', $parametrizacao->id)
            ->whereNotIn('infraestrutura_id', $infraestruturas->pluck('id'))
            ->delete();

        $infraestruturas->each(function ($data) use ($parametrizacao) {
            $parametrizacao->infraestruturas()->updateOrCreate(['infraestrutura_id' => $data['id']]);
        });
    }

    private static function validate()
    {
        return request()->validate(array_merge(
            self::getInfraestruturaValidations(),
            self::getAgendamentoValidations(),
            self::getIntegracaoAplicativoValidations(),
            self::getAtendimentoValidations(),
            self::getSigiloValidations(),
        ));
    }

    private static function getInfraestruturaValidations()
    {
        return [
            'infraestrutura.infraestruturas' => [
                'present',
                'array',
            ],
            'infraestrutura.infraestruturas.*.id' => [
                'required',
                'integer',
                Rule::exists(Infraestrutura::class, 'id'),
            ],
            'infraestrutura.infraestruturas.*.deleted' => [
                'required',
                'boolean',
            ],
            'infraestrutura.infraestruturas.*.ocupacoes' => [
                'present',
                'array',
            ],
            'infraestrutura.infraestruturas.*.ocupacoes.*.id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'infraestrutura.infraestruturas.*.ocupacoes.*.pos_consulta' => [
                'required',
                'boolean',
            ],
            'infraestrutura.infraestruturas.*.ocupacoes.*.permite_atendimento_enfermagem' => [
                'required',
                'boolean',
            ],
            'infraestrutura.infraestruturas.*.ocupacoes.*.atencao_basica_funcionalidades' => [
                'present',
                'array',
            ],
            'infraestrutura.infraestruturas.*.ocupacoes.*.atencao_basica_funcionalidades.*' => [
                'nullable',
                'integer',
                Rule::exists(Funcionalidade::class, 'id'),
            ],
            'infraestrutura.infraestruturas.*.especialidades' => [
                'present',
                'array',
            ],
            'infraestrutura.infraestruturas.*.especialidades.*.id' => [
                'required',
                'integer',
                Rule::exists(Especialidade::class, 'id'),
            ],
            'infraestrutura.infraestruturas.*.especialidades.*.avisa_falta_quantidade' => [
                'nullable',
                'integer',
                'max:999'
            ],
            'infraestrutura.infraestruturas.*.especialidades.*.avisa_falta_dias' => [
                'nullable',
                'required_with:infraestrutura.infraestruturas.*.especialidades.*.avisa_falta_quantidade',
                'integer',
                'max:999'
            ],
            'infraestrutura.infraestruturas.*.especialidades.*.quantidade_dias_retorno' => [
                'nullable',
                'integer',
                'max:999'
            ],
            'infraestrutura.infraestruturas.*.especialidades.*.demanda_espontanea_observa_vaga_atendimento' => [
                'nullable',
                'boolean',
            ],
            'infraestrutura.infraestruturas.*.especialidades.*.procedimentos' => [
                'present',
                'array',
            ],
            'infraestrutura.infraestruturas.*.especialidades.*.procedimentos.*.codigo' => [
                'required',
                'digits:10',
            ],
            'infraestrutura.infraestruturas.*.infraestruturas_agendadoras' => [
                'present',
                'array',
            ],
            'infraestrutura.infraestruturas.*.infraestruturas_agendadoras.*.id' => [
                'required',
                'integer',
                Rule::exists(Infraestrutura::class, 'id'),
            ],
            'infraestrutura.infraestruturas.*.envia_sms' => [
                'required',
                'boolean',
            ],
            'infraestrutura.infraestruturas.*.fatura_procedimento_raas' => [
                'required',
                'boolean',
            ],
            'infraestrutura.infraestruturas.*.sms.dia_antecedencia' => [
                'present',
                'nullable',
                'integer',
                'max:365',
            ],
            'infraestrutura.infraestruturas.*.sms.envio_de' => [
                'nullable',
                'required_with:infraestrutura.infraestruturas.*.sms.dia_antecedencia',
                'date_format:d/m/Y',
            ],
            'infraestrutura.infraestruturas.*.sms.envio_ate' => [
                'nullable',
                'required_with:infraestrutura.infraestruturas.*.sms.dia_antecedencia',
                'date_format:d/m/Y',
            ],
            'infraestrutura.infraestruturas.*.sms.especialidades' => [
                'present',
                'array',
            ],
            'infraestrutura.infraestruturas.*.sms.especialidades.*' => [
                'required',
                'integer',
                Rule::exists(Especialidade::class, 'id'),
            ],
            'infraestrutura.infraestruturas.*.servicos' => [
                'present',
                'array',
            ],
            'infraestrutura.infraestruturas.*.servicos.*' => [
                'required',
                'integer',
                Rule::exists(Servico::class, 'id'),
            ]
        ];
    }

    private static function getAgendamentoValidations()
    {
        return [
            'agendamento.avisa_cns_provisorio' => [
                'required',
                'boolean',
            ],
            'agendamento.avisa_paciente_outra_unidade' => [
                'required',
                'boolean',
            ],

            'agendamento.bloqueia_paciente_temporario' => [
                'required',
                'boolean',
            ],
            'agendamento.obriga_motivo_agendamento_excedente' => [
                'required',
                'boolean',
            ],
            'agendamento.permite_agendar_mesma_especialidade' => [
                'required',
                'boolean',
            ],
            'agendamento.gerenciar_tratamento' => [
                'required',
                'boolean',
            ],
        ];
    }

    private static function getIntegracaoAplicativoValidations()
    {
        return [
            'integracao_aplicativo.habilita_integracao_conectasus_cidadao' => [
                'required',
                'boolean',
            ],
            'integracao_aplicativo.habilita_integracao_aplicativo_feridas' => [
                'required',
                'boolean',
            ],
        ];
    }

    private static function getAtendimentoValidations()
    {
        return [
            'atendimento.exibe_mensagem_atendimento_retroativo_nao_finalizado' => [
                'required',
                'boolean',
            ],
            'atendimento.prescricao_limite_dias' => [
                'nullable',
                'integer',
                'max:730',
            ]
        ];
    }

    private static function getSigiloValidations()
    {
        return [
            'sigilo.sigilos' => [
                'present',
                'array',
            ],
            'sigilo.sigilos.*.ocupacao_id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'sigilo.sigilos.*.infraestrutura_id' => [
                'nullable',
                'integer',
                Rule::exists(Infraestrutura::class, 'id'),
            ],
            'sigilo.sigilos.*.deleted' => [
                'required',
                'boolean',
            ],
            'sigilo.sigilos.*.infraestruturas' => [
                'present',
                'array',
            ],
            'sigilo.sigilos.*.infraestruturas.*.id' => [
                'required',
                'integer',
                Rule::exists(Infraestrutura::class, 'id'),
            ],
            'sigilo.sigilos.*.ocupacoes' => [
                'present',
                'array',
            ],
            'sigilo.sigilos.*.ocupacoes.*.id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
        ];
    }

    public static function getQuantidadeDiasRetorno($infraestruturaId, $especialidadeId)
    {
        $parametrizacaoInfraestrutura = ParametrizacaoInfraestrutura::where('infraestrutura_id', $infraestruturaId)
            ->first();

        if (!is_null($parametrizacaoInfraestrutura)) {

            $parametrizacaoEspecialidade = $parametrizacaoInfraestrutura->especialidades()
                ->where('especialidade_id', $especialidadeId)
                ->first();

            if (!is_null($parametrizacaoEspecialidade)) {

                return $parametrizacaoEspecialidade->quantidade_dias_retorno ?? 0;
            }
        }

        return 0;
    }
}