<?php

namespace App\Http\Requests\ProntoAtendimento\Atendimento;

use App\Enums\Cadastro\Estabelecimento\SetorTipo;
use App\Enums\Cadastro\Medicamento\TipoPosologia;
use App\Enums\Cadastro\Medicamento\ViaAdministracao;
use App\Enums\Cadastro\SujeitoAtencao\FatorRisco;
use App\Enums\Cadastro\UnidadeMedida;
use App\Enums\Geral\DocumentoTipo;
use App\Enums\Parametrizacao\ProntoAtendimento\TipoAtendimento;
use App\Enums\ProntoAtendimento\Atendimento\Desfecho;
use App\Enums\ProntoAtendimento\Atendimento\Medico\AtestadoModelo;
use App\Enums\ProntoAtendimento\Atendimento\Medico\DeclaracaoComparecimentoTipo;
use App\Enums\ProntoAtendimento\Raat\CausaAcidente;
use App\Enums\ProntoAtendimento\Raat\Diagnostico;
use App\Enums\ProntoAtendimento\Raat\ParteCorpoAtingida;
use App\Enums\Sigtap\Procedimento as ProcedimentoEnum;
use App\Http\Requests\FormRequest;
use App\Models\Cadastro\Estabelecimento\CentroCusto;
use App\Models\Cadastro\Medicamento\Medicamento;
use App\Models\Cadastro\SujeitoAtencao\Lotacao;
use App\Models\ProntoAtendimento\Atendimento\Atendimento;
use App\Models\ProntoAtendimento\Parametrizacao\AtendimentoMedico as ParametrizacaoAtendimentoMedico;
use App\Models\Sigtap\Procedimento;
use App\Rules\Cns;
use App\Rules\CnsTermoValido;
use App\Rules\Cpf;
use App\Rules\NomeCompleto;
use App\Services\Parametrizacao\ProntoAtendimento\AtendimentoMedicoService as ParametrizacaoAtendimentoMedicoService;
use App\Services\Sigtap\ProcedimentoValidationService;
use App\Utils\RequestUtil;
use Carbon\Carbon;
use Illuminate\Validation\Rule;

class MedicoRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        switch ($this->method()) {

            case 'POST': {

                return $this->getPostRules();
            }
            default: {

                return [];
            }
        }
    }

    private function getPostRules()
    {
        $atendimento = is_numeric($this->atendimento_id ?? null)
            ? Atendimento::find($this->atendimento_id)
            : null;

        $rules = [
            'plantao_id' => [
                'required',
                'integer'
            ],
            'atendimento_id' => [
                'required',
                'integer',
                'exists:\App\Models\ProntoAtendimento\Atendimento\Atendimento,id'
            ],
        ];

        if (is_null($atendimento)) {

            return $rules;
        }

        $centroCustoLogado = $this->getCentroCustoLogado();
        $parametrizacao = ParametrizacaoAtendimentoMedicoService::get($centroCustoLogado->infraestrutura_id);

        $isAtendimentoSimples = $parametrizacao->tipo_id === TipoAtendimento::SIMPLES;
        $isReavaliacao = $atendimento->atendimentosMedico()->get()->isNotEmpty();
        $isPrimeiroAtendimentoSimples = !$isReavaliacao && $isAtendimentoSimples;
        $isPrimeiroAtendimentoEstruturado = !$isReavaliacao && !$isAtendimentoSimples;

        $raatObrigatorio = !is_null($this->desfecho['id'] ?? null) && $atendimento->faa->isRaatAberta;

        $procedimentoPadrao = ParametrizacaoAtendimentoMedico::first()->procedimento_padrao ?? null;

        $rules = array_merge($rules, [
            'classificacao_risco_id' => [
                'required',
                'integer',
                'exists:\App\Models\ProntoAtendimento\ClassificacaoRisco\ClassificacaoRisco,id'
            ],
            'evolucao' => [
                'nullable',
                Rule::requiredIf(fn () => $isReavaliacao),
                'string',
                'max:5000',
            ],
            'atendimento_geral' => [
                'nullable',
                Rule::requiredIf(fn () => $isPrimeiroAtendimentoSimples),
                'string',
                'max:5000',
            ],
            'queixa_principal_duracao' => [
                'nullable',
                ($isPrimeiroAtendimentoEstruturado
                    ? 'required_without_all:'
                        . 'historia,'
                        . 'exame_fisico,'
                        . 'diagnostico,'
                        . 'conduta'
                    : null),
                'string',
                'max:5000',
            ],
            'historia' => [
                'nullable',
                ($isPrimeiroAtendimentoEstruturado
                    ? 'required_without_all:'
                        . 'queixa_principal_duracao,'
                        . 'exame_fisico,'
                        . 'diagnostico,'
                        . 'conduta'
                    : null),
                'string',
                'max:5000',
            ],
            'exame_fisico' => [
                'nullable',
                ($isPrimeiroAtendimentoEstruturado
                    ? 'required_without_all:'
                        . 'queixa_principal_duracao,'
                        . 'historia,'
                        . 'diagnostico,'
                        . 'conduta'
                    : null),
                'string',
                'max:5000',
            ],
            'diagnostico' => [
                'nullable',
                ($isPrimeiroAtendimentoEstruturado
                    ? 'required_without_all:'
                        . 'queixa_principal_duracao,'
                        . 'historia,'
                        . 'exame_fisico,'
                        . 'conduta'
                    : null),
                'string',
                'max:5000',
            ],
            'conduta' => [
                'nullable',
                ($isPrimeiroAtendimentoEstruturado
                    ? 'required_without_all:'
                        . 'queixa_principal_duracao,'
                        . 'historia,'
                        . 'exame_fisico,'
                        . 'diagnostico'
                    : null),
                'string',
                'max:5000',
            ],
            'observacoes' => [
                'nullable',
                'string',
                'max:5000',
            ],
            'dor_toracica_resultado_eletrocardiograma' => [
                'nullable',
                'string',
                'max:5000',
            ],
            'dor_toracica_protocolo_finalizado' => [
                'nullable',
                'boolean',
            ],
            'dor_toracica_protocolo_tem_prosseguimento' => [
                'nullable',
                'boolean',
            ],
            'dor_toracica_tem_contra_indicacao_trombolitico' => [
                'nullable',
                'boolean',
            ],
            'dor_toracica_contra_indicacao_trombolitico_motivo' => [
                'nullable',
                'string',
                'max:200',
            ],
            'dor_toracica_sinais_instabilidade' => [
                'present',
                'array',
            ],
            'dor_toracica_sinais_instabilidade.*' => [
                'present',
                'integer',
            ],
            'doencas_cronicas' => [
                'nullable',
                'string',
                'max:3000',
            ],
            'cid_id' => [
                'nullable',
                Rule::requiredIf(fn () => !$isReavaliacao),
                'integer',
            ],
            'orientacoes' => [
                'nullable',
                'string',
                'between:2,3000',
            ],
            'centro_custo_id_para' => [
                'nullable',
                Rule::requiredIf(fn () => !$this->hasFinalizacao() && !$this->fromObservacao($atendimento)),
                'integer',
                'exists:\App\Models\Cadastro\Estabelecimento\CentroCusto,id',
            ],
            'observacoes_enfermagem' => [
                'nullable',
                'string',
                'max:5000',
            ],
            'data_hora_proxima_reavaliacao' => [
                'bail',
                'nullable',
                Rule::requiredIf(fn () =>
                    $this->fromObservacao($atendimento) && is_null($this->desfecho['id'] ?? null)
                    || (
                        $this->isCentroCustoParaObservacao($this->centro_custo_id_para)
                        && !$this->fromObservacao($atendimento)
                        && is_null($this->desfecho['id'] ?? null)
                    )
                ),
                'date_format:d/m/Y H:i',
                function ($attribute, $value, $fail) {

                    if (!$value) return;

                    $dataAtual = Carbon::now();
                    $dataLimite = $dataAtual->copy()->modify('+24 hours');
                    $dataProximaReavaliacao = Carbon::createFromFormat('d/m/Y H:i', $value);

                    if ($dataProximaReavaliacao <= $dataAtual) {

                        $fail("Data/hora da próxima reavaliação deve ser maior "
                            . "que {$dataAtual->format('d/m/Y H:i')}.");
                    }
                    else if ($dataProximaReavaliacao > $dataLimite) {

                        $fail("Data/hora da próxima reavaliação deve ser menor ou "
                            . "igual a {$dataLimite->format('d/m/Y H:i')}.");
                    }
                },
            ],
            'fatores_risco' => [
                'nullable',
                'array',
            ],
            'fatores_risco.*' => [
                'integer',
                'exists:\App\Models\Cadastro\SujeitoAtencao\FatorRisco,id',
            ],
            'fator_risco_outro' => [
                'nullable',
                Rule::requiredIf(fn () => in_array(FatorRisco::OUTRO, $this->fatores_risco ?? [])),
                'string',
                'max:100',
            ],
            'escala_coma_glasgow' => [
                'nullable',
                'array',
            ],
            'escala_coma_glasgow.*.abertura_ocular_id' => [
                'required',
                'integer',
                'exists:\App\Models\Geral\GlasgowAberturaOcular,id'
            ],
            'escala_coma_glasgow.*.resposta_verbal_id' => [
                'required',
                'integer',
                'exists:\App\Models\Geral\GlasgowRespostaVerbal,id'
            ],
            'escala_coma_glasgow.*.resposta_motora_id' => [
                'required',
                'integer',
                'exists:\App\Models\Geral\GlasgowRespostaMotora,id'
            ],
            'escala_coma_glasgow.*.reatividade_pupilar_id' => [
                'required',
                'integer',
                'exists:\App\Models\Geral\GlasgowReatividadePupilar,id'
            ],
            'escala_coma_glasgow.*.observacao' => [
                'nullable',
                'string',
                'max:2500'
            ],
        ]);

        return array_merge(
            $rules,
            $this->getPostAlergiaRules(),
            $this->getPostMedicamentosUsoRules(),
            $this->getPostSinaisVitaisRules(),
            $this->getPostAvaliacaoAntropometricaRules(),
            $this->getPostGestacaoRules(),
            $this->getPostAtestadoRules(),
            $this->getPostReceitaMedicaRules(),
            $this->getPostPrescricaoInternaRules(),
            $this->getPostEncaminhamentosRules(),
            $this->getPostDeclaracoesComparecimentoRules(),
            $this->getPostRaatRules($raatObrigatorio),
            $this->getPostProcedimentosRules($isReavaliacao, $atendimento, $procedimentoPadrao),
            $this->getPostPedidoExameRules($atendimento),
            $this->getPostServicosEnfermagemRules($atendimento),
            $this->getPostDesfechoRules($atendimento),
            $this->getPostFinalizacaoRules($atendimento, $raatObrigatorio),
        );
    }

    private function fromObservacao($atendimento)
    {
        return $atendimento->fila->centroCusto->setor->tipo_id === SetorTipo::OBSERVACAO;
    }

    private function isCentroCustoParaObservacao($centroCustoIdPara)
    {
        if (is_null($centroCustoIdPara)) {

            return false;
        }

        $centroCustoPara = CentroCusto::findOrFail($centroCustoIdPara);

        return $centroCustoPara->setor->tipo_id === SetorTipo::OBSERVACAO;
    }

    private function getPostAlergiaRules()
    {
        return [
            'alergias' => [
                'nullable',
                'array',
            ],
            'alergias.*.alergia_id' => [
                'required',
                'integer',
                'exists:\App\Models\Cadastro\SujeitoAtencao\Alergia,id',
            ],
            'alergias.*.criticidade_id' => [
                'required',
                'integer',
                'exists:\App\Models\Cadastro\SujeitoAtencao\AlergiaCriticidade,id',
            ],
            'alergias.*.reacoes_observacoes' => [
                'nullable',
                'string',
                'between:3,100',
            ],
        ];
    }

    private function getPostMedicamentosUsoRules()
    {
        return [
            'medicamentos_uso' => [
                'nullable',
                'string',
                'max:3000',
            ],
        ];
    }

    private function getPostSinaisVitaisRules()
    {
        $rules = [
            'sinais_vitais' => [
                'nullable',
                'array',
            ],
            'sinais_vitais.*.pa_unidade_medida_id' => [
                'nullable',
                'required_with:sinais_vitais.*.pa',
                'integer',
                Rule::in([UnidadeMedida::MILIMETROS_DE_MERCURIO, UnidadeMedida::CENTIMETROS_DE_MERCURIO]),
            ],
            'sinais_vitais.*.glicemia' => [
                'nullable',
                'required_without_all:'
                    . 'sinais_vitais.*.pa,'
                    . 'sinais_vitais.*.temperatura,'
                    . 'sinais_vitais.*.pulso,'
                    . 'sinais_vitais.*.respiracao,'
                    . 'sinais_vitais.*.saturacao,'
                    . 'sinais_vitais.*.intensidade_dor,'
                    . 'sinais_vitais.*.cintura',
                'integer',
                'max:999',
            ],
            'sinais_vitais.*.temperatura' => [
                'nullable',
                'required_without_all:'
                    . 'sinais_vitais.*.pa,'
                    . 'sinais_vitais.*.glicemia,'
                    . 'sinais_vitais.*.pulso,'
                    . 'sinais_vitais.*.respiracao,'
                    . 'sinais_vitais.*.saturacao,'
                    . 'sinais_vitais.*.intensidade_dor,'
                    . 'sinais_vitais.*.cintura',
                'numeric',
                'max:99.9',
            ],
            'sinais_vitais.*.pulso' => [
                'nullable',
                'required_without_all:'
                    . 'sinais_vitais.*.pa,'
                    . 'sinais_vitais.*.glicemia,'
                    . 'sinais_vitais.*.temperatura,'
                    . 'sinais_vitais.*.respiracao,'
                    . 'sinais_vitais.*.saturacao,'
                    . 'sinais_vitais.*.intensidade_dor,'
                    . 'sinais_vitais.*.cintura',
                'integer',
                'max:999',
            ],
            'sinais_vitais.*.respiracao' => [
                'nullable',
                'required_without_all:'
                    . 'sinais_vitais.*.pa,'
                    . 'sinais_vitais.*.glicemia,'
                    . 'sinais_vitais.*.temperatura,'
                    . 'sinais_vitais.*.pulso,'
                    . 'sinais_vitais.*.saturacao,'
                    . 'sinais_vitais.*.intensidade_dor,'
                    . 'sinais_vitais.*.cintura',
                'integer',
                'max:99',
            ],
            'sinais_vitais.*.saturacao' => [
                'nullable',
                'required_without_all:'
                    . 'sinais_vitais.*.pa,'
                    . 'sinais_vitais.*.glicemia,'
                    . 'sinais_vitais.*.temperatura,'
                    . 'sinais_vitais.*.pulso,'
                    . 'sinais_vitais.*.respiracao,'
                    . 'sinais_vitais.*.intensidade_dor,'
                    . 'sinais_vitais.*.cintura',
                'integer',
                'between:1,100',
            ],
            'sinais_vitais.*.intensidade_dor' => [
                'nullable',
                'required_without_all:'
                    . 'sinais_vitais.*.pa,'
                    . 'sinais_vitais.*.glicemia,'
                    . 'sinais_vitais.*.temperatura,'
                    . 'sinais_vitais.*.pulso,'
                    . 'sinais_vitais.*.respiracao,'
                    . 'sinais_vitais.*.saturacao,'
                    . 'sinais_vitais.*.cintura',
                'integer',
                'between:1,10',
            ],
            'sinais_vitais.*.cintura' => [
                'nullable',
                'required_without_all:'
                    . 'sinais_vitais.*.pa,'
                    . 'sinais_vitais.*.glicemia,'
                    . 'sinais_vitais.*.temperatura,'
                    . 'sinais_vitais.*.pulso,'
                    . 'sinais_vitais.*.respiracao,'
                    . 'sinais_vitais.*.saturacao,'
                    . 'sinais_vitais.*.intensidade_dor,',
                'integer',
                'max:999',
            ],
        ];

        foreach (($this->sinais_vitais ?? []) as $i => $sinalVital) {

            $rules["sinais_vitais.{$i}.pa"] = [
                'nullable',
                'required_without_all:'
                    . "sinais_vitais.{$i}.glicemia,"
                    . "sinais_vitais.{$i}.temperatura,"
                    . "sinais_vitais.{$i}.pulso,"
                    . "sinais_vitais.{$i}.respiracao,"
                    . "sinais_vitais.{$i}.saturacao,"
                    . "sinais_vitais.{$i}.intensidade_dor,"
                    . "sinais_vitais.{$i}.cintura'",
                'string',
            ];

            if ($sinalVital['pa_unidade_medida_id'] === UnidadeMedida::MILIMETROS_DE_MERCURIO) {

                $rules["sinais_vitais.{$i}.pa"][] = 'regex:/^[0-9]{2,3}\/+[0-9]{2,3}$/';
            }
            else if ($sinalVital['pa_unidade_medida_id'] === UnidadeMedida::CENTIMETROS_DE_MERCURIO) {

                $rules["sinais_vitais.{$i}.pa"][] = 'regex:/^[0-9]{1,2}\/+[0-9]{1,2}$/';
            }
        }

        return $rules;
    }

    private function getPostAvaliacaoAntropometricaRules()
    {
        $rules = [
            'avaliacao_antropometrica' => [
                'nullable',
                'array',
            ],
        ];

        if (is_array($this->avaliacao_antropometrica ?? null)) {

            $rules = array_merge($rules, [
                'avaliacao_antropometrica.massa' => [
                    'nullable',
                    'required_without:avaliacao_antropometrica.altura',
                    'numeric',
                    'max:999.999',
                ],
                'avaliacao_antropometrica.massa_unidade_medida_id' => [
                    'nullable',
                    'required_with:avaliacao_antropometrica.massa',
                    'integer',
                    Rule::in([UnidadeMedida::GRAMAS, UnidadeMedida::QUILOGRAMAS]),
                ],
                'avaliacao_antropometrica.altura' => [
                    'nullable',
                    'required_without:avaliacao_antropometrica.massa',
                    'numeric',
                    'max:999.99',
                ],
                'avaliacao_antropometrica.altura_unidade_medida_id' => [
                    'nullable',
                    'required_with:avaliacao_antropometrica.altura',
                    'integer',
                    Rule::in([UnidadeMedida::CENTIMETROS, UnidadeMedida::METROS]),
                ],
                'avaliacao_antropometrica.altura_tipo_medida_id' => [
                    'nullable',
                    'required_with:avaliacao_antropometrica.altura',
                    'integer',
                    'exists:\App\Models\Geral\TipoMedidaAltura,id',
                ],
            ]);
        }

        return $rules;
    }

    private function getPostGestacaoRules()
    {
        $rules = [
            'gestacao' => [
                'nullable',
                'array',
            ],
        ];

        if (is_array($this->gestacao ?? null)) {

            $rules = array_merge($rules, [
                'gestacao.gestante' => [
                    'required',
                    'boolean',
                ],
                'gestacao.dum' => [
                    'nullable',
                    'date_format:Y-m-d',
                    'before_or_equal:now',
                ],
            ]);
        }

        return $rules;
    }

    private function getPostAtestadoRules()
    {
        $modeloId = (int) ($this->atestado['modelo_id'] ?? AtestadoModelo::PADRAO);

        $rules = [
            'atestado' => [
                'nullable',
                'array'
            ],
        ];

        if (is_array($this->atestado ?? null)) {

            $rules = array_merge($rules, [
                'atestado.modelo_id' => [
                    'required',
                    'integer',
                    Rule::in([
                        AtestadoModelo::PADRAO,
                        AtestadoModelo::PERIODO_MANHA,
                        AtestadoModelo::PERIODO_TARDE,
                        AtestadoModelo::PERIODO_NOITE,
                        AtestadoModelo::QUANTIDADE_HORAS,
                    ]),
                ],
                'atestado.dias' => [
                    'nullable',
                    Rule::requiredIf(fn () => $modeloId === AtestadoModelo::PADRAO),
                    'integer',
                    'max:999'
                ],
                'atestado.quantidade_horas' => [
                    'nullable',
                    Rule::requiredIf(fn () => $modeloId === AtestadoModelo::QUANTIDADE_HORAS),
                    'integer',
                    'between:1,24',
                ],
                'atestado.horario_inicial' => [
                    'nullable',
                    Rule::requiredIf(fn () => $modeloId === AtestadoModelo::QUANTIDADE_HORAS),
                    'date_format:H:i',
                ],
                'atestado.documento_tipo_id' => [
                    'required',
                    'integer',
                    'exists:\App\Models\Geral\DocumentoTipo,id'
                ],
                'atestado.documento_numero' => [
                    'required',
                    ($this->atestado['paciente'] == 1 ? 'digits_between:2,20' : ''),
                ],
            ]);
        }

        return $rules;
    }

    private function getPostReceitaMedicaRules()
    {
        $rules = [
            'receitas_medicas_assinadas' => [
                'present',
                'array',
            ],
            'receitas_medicas_assinadas.*' => [
                'array',
            ],
            'receitas_medicas_assinadas.*.*' => [
                'string',
            ],
            'receita_medica' => [
                'nullable',
                'array'
            ],
        ];

        if (is_array($this->receita_medica ?? null)) {

            $rules["receita_medica.is_assinada"] = [
                'required',
                'boolean',
            ];

            $rules["receita_medica.medicamentos"] = [
                'present',
                'array',
            ];

            if (is_array($this->receita_medica['medicamentos'] ?? null)) {

                foreach ($this->receita_medica['medicamentos'] as $i => $params) {

                    $rules["receita_medica.medicamentos.{$i}.medicamento_id"] = [
                        'nullable',
                        'integer',
                    ];

                    $rules["receita_medica.medicamentos.{$i}.tipo_aplicacao"] = [
                        'required',
                        'string',
                        Rule::in(['dose_unica', 'uso_continuo', 'livre', 'padrao'])
                    ];

                    if (!is_numeric($params['medicamento_id'] ?? null)
                        || !is_string($params['tipo_aplicacao'] ?? null)
                    ) {

                        continue;
                    }

                    $rules["receita_medica.medicamentos.{$i}.via_administracao_outras"] = [
                        'nullable',
                        Rule::requiredIf(fn () => (Medicamento::find($params['medicamento_id'])
                            ->via_administracao_id ?? null) === ViaAdministracao::OUTRAS
                        ),
                        'string',
                        'max:100'
                    ];

                    $usoContinuo = $params['tipo_aplicacao'] === 'uso_continuo';
                    $livre = $params['tipo_aplicacao'] === 'livre';
                    $padrao = $params['tipo_aplicacao'] === 'padrao';

                    $rules["receita_medica.medicamentos.{$i}.tipo_posologia"] = [
                        'nullable',
                        Rule::requiredIf(fn () => $padrao || $usoContinuo),
                        Rule::in([TipoPosologia::FREQUENCIA, TipoPosologia::TURNO]),
                        'string',
                    ];

                    $rules["receita_medica.medicamentos.{$i}.quantidade"] = [
                        'nullable',
                        Rule::requiredIf(fn () => !$livre),
                        'numeric',
                        'between:0.1,999',
                    ];

                    if (is_string($params['tipo_posologia'] ?? null)) {

                        $posologiaPorFrequencia = $params['tipo_posologia'] === TipoPosologia::FREQUENCIA;
                        $posologiaPorTurno = $params['tipo_posologia'] === TipoPosologia::TURNO;

                        $rules["receita_medica.medicamentos.{$i}.intervalo_tempo"] = [
                            'nullable',
                            Rule::requiredIf(fn () => $posologiaPorFrequencia),
                            'integer',
                            'between:1,999',
                        ];

                        $rules["receita_medica.medicamentos.{$i}.intervalo_medida_tempo_id"] = [
                            'nullable',
                            Rule::requiredIf(fn () => $posologiaPorFrequencia),
                            'integer',
                            'exists:\App\Models\Geral\MedidaTempo,id',
                        ];

                        $rules["receita_medica.medicamentos.{$i}.turno_id"] = [
                            'nullable',
                            Rule::requiredIf(fn () => $posologiaPorTurno),
                            'integer',
                            'exists:\App\Models\Geral\Turno,id',
                        ];
                    }

                    $rules["receita_medica.medicamentos.{$i}.durante_tempo"] = [
                        'nullable',
                        Rule::requiredIf(fn () => $padrao),
                        'between:1,999',
                    ];

                    $rules["receita_medica.medicamentos.{$i}.durante_medida_tempo_id"] = [
                        'nullable',
                        Rule::requiredIf(fn () => $padrao),
                        'integer',
                        'exists:\App\Models\Geral\MedidaTempo,id',
                    ];

                    $rules["receita_medica.medicamentos.{$i}.recomendacoes"] = [
                        'nullable',
                        'string',
                        'max:250',
                    ];

                    $rules["receita_medica.medicamentos.{$i}.descricao"] = [
                        'nullable',
                        Rule::requiredIf(fn () => $livre),
                        'string',
                        'max:250',
                    ];

                    $rules["receita_medica.medicamentos.{$i}.medicamento_manual"] = [
                        'nullable',
                        'string',
                        'max:500',
                    ];

                    $rules["receita_medica.medicamentos.{$i}.prescricao_manual"] = [
                        'nullable',
                        'string',
                        'max:5000',
                    ];
                }
            }
        }

        return $rules;
    }

    private function getPostPrescricaoInternaRules()
    {
        $rules = [
            'prescricoes_internas' => [
                'nullable',
                'array',
            ],
        ];

        if (is_array($this->prescricoes_internas ?? null)) {

            foreach ($this->prescricoes_internas as $i => $prescricaoInterna) {

                $rules["prescricoes_internas.{$i}.dose_unica"] = [
                    'required',
                    'boolean',
                ];

                $rules["prescricoes_internas.{$i}"][] = function ($attribute, $value, $fail) use ($prescricaoInterna) {

                    $faltando = false;

                    if (!isset($prescricaoInterna['dose_unica'])) {
                        $faltando = true;
                    }

                    if (
                        isset($prescricaoInterna['dose_unica']) &&
                        RequestUtil::isAcceptedBoolean($prescricaoInterna['dose_unica']) &&
                        !((bool) $prescricaoInterna['dose_unica'])
                    ) {
                        if (
                            empty($prescricaoInterna['frequencia_quantidade_vezes']) ||
                            empty($prescricaoInterna['frequencia_tempo']) ||
                            empty($prescricaoInterna['frequencia_medida_tempo_id'])
                        ) {
                            $faltando = true;
                        }
                    }

                    if (empty($prescricaoInterna['medicamentos']) || !is_array($prescricaoInterna['medicamentos'])) {
                        $faltando = true;
                    }

                    if ($faltando) {
                        $fail('Acessar a Prescrição Interna e preencher os campos corretamente.');
                    }
                };

                if (RequestUtil::isAcceptedBoolean($prescricaoInterna['dose_unica'] ?? null)
                    && !((bool) $prescricaoInterna['dose_unica'])
                ) {

                    $rules["prescricoes_internas.{$i}.frequencia_quantidade_vezes"] = [
                        'required',
                        'integer',
                        'between:1,999',
                    ];

                    $rules["prescricoes_internas.{$i}.frequencia_tempo"] = [
                        'required',
                        'integer',
                        'between:1,999',
                    ];

                    $rules["prescricoes_internas.{$i}.frequencia_medida_tempo_id"] = [
                        'required',
                        'integer',
                        'exists:\App\Models\Geral\MedidaTempo,id',
                    ];
                }

                $rules["prescricoes_internas.{$i}.observacoes"] = [
                    'nullable',
                    'string',
                    'max:250'
                ];

                $rules["prescricoes_internas.{$i}.medicamentos"] = [
                    'required',
                    'array',
                ];

                if (!is_array($prescricaoInterna['medicamentos'] ?? null)) {

                    continue;
                }

                foreach ($prescricaoInterna['medicamentos'] as $j => $params) {

                    $medicamento = is_numeric($params['medicamento_id'] ?? null)
                        ? Medicamento::find($params['medicamento_id'])
                        : null;

                    $rules["prescricoes_internas.{$i}.medicamentos.{$j}.medicamento_id"] = [
                        'required',
                        'integer',
                    ];

                    $rules["prescricoes_internas.{$i}.medicamentos.{$j}.unidade_medida_id"] = [
                        'nullable',
                        'integer',
                    ];

                    $rules["prescricoes_internas.{$i}.medicamentos.{$j}.quantidade"] = [
                        'required',
                        'numeric',
                        'between:0.1,99',
                    ];

                    $rules["prescricoes_internas.{$i}.medicamentos.{$j}.administracao"] = [
                        'nullable',
                        'string',
                        'max:3000',
                    ];

                    if (is_null($medicamento)) {

                        continue;
                    }

                    $rules["prescricoes_internas.{$i}.medicamentos.{$j}.medicamento_id"][] =
                        function ($attribute, $value, $fail) use ($j, $prescricaoInterna) {

                            foreach ($prescricaoInterna['medicamentos'] as $k => $params) {

                                if ($j === $k || !isset($params['medicamento_id'])) {

                                    continue;
                                }

                                if ($value == $params['medicamento_id']) {

                                    $fail('O campo ' . $attribute . ' campo tem um valor duplicado.');
                                }
                            }
                        };
                }

            }
        }

        return $rules;
    }

    private function isPrescricaoDuplicada($medicamentos, $currentIndex)
    {
        $idsMedicamentosAtual = [];

        foreach ($medicamentos as $params) {

            if (!isset($params['medicamento_id'])) {

                return false;
            }

            $idsMedicamentosAtual[] = $params['medicamento_id'];
        }

        foreach ($this->prescricoes_internas as $j => $prescricaoInterna) {

            if ($currentIndex === $j) {

                continue;
            }

            $idsMedicamentos = [];

            foreach ($prescricaoInterna['medicamentos'] as $params) {

                if (!isset($params['medicamento_id'])) {

                    continue 2;
                }

                $idsMedicamentos[] = $params['medicamento_id'];
            }

            if (count($idsMedicamentosAtual) === count($idsMedicamentos)
                && empty(array_diff($idsMedicamentosAtual, $idsMedicamentos))
            ) {

                return true;
            }
        }

        return false;
    }

    private function getPostEncaminhamentosRules()
    {
        return [
            'encaminhamentos' => [
                'nullable',
                'array',
            ],
            'encaminhamentos.*.urgente' => [
                'required',
                'boolean',
            ],
            'encaminhamentos.*.ocupacao_id' => [
                'required',
                'integer',
                'distinct',
                'exists:\App\Models\Sigtap\Ocupacao,id',
            ],
            'encaminhamentos.*.motivo' => [
                'required',
                'string',
                'max:300',
            ],
            'encaminhamentos.*.observacoes' => [
                'nullable',
                'string',
                'max:300',
            ],
        ];
    }

    private function getPostDeclaracoesComparecimentoRules()
    {
        $rules = [
            'declaracoes_comparecimento' => [
                'nullable',
                'array',
            ],
        ];

        if (is_array($this->declaracoes_comparecimento ?? null)) {

            foreach ($this->declaracoes_comparecimento as $i => $declaracaoComparecimento) {

                $rules["declaracoes_comparecimento.{$i}.tipo_id"] = [
                    'required',
                    'integer',
                    'exists:\App\Models\ProntoAtendimento\Atendimento\Medico\DeclaracaoComparecimentoTipo,id',
                ];

                $rules["declaracoes_comparecimento.{$i}.nome"] = [
                    Rule::requiredIf(fn () =>
                        ($declaracaoComparecimento['tipo_id'] ?? null) == DeclaracaoComparecimentoTipo::ACOMPANHANTE),
                    'string',
                    'between:6,150',
                    ($declaracaoComparecimento['tipo_id'] ?? null) == DeclaracaoComparecimentoTipo::ACOMPANHANTE
                        ? new NomeCompleto
                        : null,
                    ($declaracaoComparecimento['tipo_id'] ?? null) == DeclaracaoComparecimentoTipo::ACOMPANHANTE
                        ? new CnsTermoValido(['attribute' => 'Acompanhante'])
                        : null,
                ];

                $rules["declaracoes_comparecimento.{$i}.documento_tipo_id"] = [
                    'required',
                    'integer',
                    'exists:\App\Models\Geral\DocumentoTipo,id',
                ];

                $rules["declaracoes_comparecimento.{$i}.documento_numero"] = [
                    'required',
                    'between:2,20',
                    $this->getDocumentoNumeroValidation($declaracaoComparecimento['documento_tipo_id'] ?? null)
                ];

                $rules["declaracoes_comparecimento.{$i}.de"] = [
                    'required',
                    'date_format:Y-m-d H:i',
                ];

                $rules["declaracoes_comparecimento.{$i}.ate"] = [
                    'required',
                    'date_format:Y-m-d H:i',
                    "after_or_equal:declaracoes_comparecimento.{$i}.de"
                ];

                $rules["declaracoes_comparecimento.{$i}.motivo"] = [
                    'required',
                    'string',
                    'between:2,50',
                ];
            }
        }

        return $rules;
    }

    private function getPostRaatRules($required)
    {
        if ($this->finalizacao && ($this->finalizacao['desfecho_id'] == Desfecho::EVASAO
            || $this->finalizacao['desfecho_id'] == Desfecho::OBITO)
        ) {
            $required = false;
        }

        $rules = [
            'raat' => [
                'nullable',
                Rule::requiredIf(fn () => $required),
                'array',
            ],
        ];

        if (is_array($this->raat ?? null)) {

            $rules = array_merge($rules, [
                'raat.agente_id' => [
                    'required',
                    'integer',
                    'exists:\App\Models\ProntoAtendimento\Raat\Agente,id',
                ],
                'raat.partes_corpo_atingidas' => [
                    'required',
                    'array',
                ],
                'raat.partes_corpo_atingidas.*' => [
                    'integer',
                    'exists:\App\Models\ProntoAtendimento\Raat\ParteCorpoAtingida,id',
                ],
                'raat.parte_corpo_atingida_outras' => [
                    'nullable',
                    Rule::requiredIf(fn () => in_array(
                        ParteCorpoAtingida::OUTROS,
                        $this->raat['partes_corpo_atingidas'] ?? [])
                    ),
                    'string',
                    'between:3,150',
                ],
                'raat.causas_acidente' => [
                    'required',
                    'array',
                ],
                'raat.causas_acidente.*' => [
                    'integer',
                    'exists:\App\Models\ProntoAtendimento\Raat\CausaAcidente,id',
                ],
                'raat.causa_acidente_outras' => [
                    'nullable',
                    Rule::requiredIf(fn () => in_array(
                        CausaAcidente::OUTROS,
                        $this->raat['causas_acidente'] ?? [])
                    ),
                    'string',
                    'between:3,150',
                ],
                'raat.diagnosticos' => [
                    'required',
                    'array',
                ],
                'raat.diagnosticos.*' => [
                    'integer',
                    'exists:\App\Models\ProntoAtendimento\Raat\Diagnostico,id',
                ],
                'raat.diagnostico_outros' => [
                    'nullable',
                    Rule::requiredIf(fn () => in_array(
                        Diagnostico::OUTROS,
                        $this->raat['diagnosticos'] ?? [])
                    ),
                    'string',
                    'between:3,150',
                ],
                'raat.observacao' => [
                    'nullable',
                    'string',
                    'between:3,150',
                ],
                'raat.classificacao_inicial_id' => [
                    'required',
                    'integer',
                    'exists:\App\Models\ProntoAtendimento\Raat\ClassificacaoInicial,id',
                ],
                'raat.afastado' => [
                    'required',
                    'boolean',
                ]
            ]);
        }

        return $rules;
    }

    private function getDocumentoNumeroValidation($documentoTipoId)
    {
        switch ($documentoTipoId) {

            case DocumentoTipo::CPF: {

                return new Cpf;
            }
            case DocumentoTipo::CNS: {

                return new Cns;
            }
            default: {

                return null;
            }
        }
    }

    private function getPostProcedimentosRules($isReavaliacao, $atendimento, $procedimentoPadrao)
    {
        $rules = [
            'procedimentos' => [
                'nullable',
                Rule::requiredIf(fn () => !$isReavaliacao && is_null($procedimentoPadrao)),
                'array',
            ],
        ];

        if (is_array($this->procedimentos ?? null)) {

            foreach ($this->procedimentos as $i => $params) {

                $procedimento = is_numeric($params['procedimento_id'] ?? null)
                    ? Procedimento::find($params['procedimento_id'])
                    : null;

                $rules["procedimentos.{$i}.procedimento_id"] = [
                    'required',
                    'integer',
                    Rule::notIn([
                        ProcedimentoEnum::AFERICAO_PRESSAO_ARTERIAL,
                        ProcedimentoEnum::GLICEMIA_CAPILAR,
                    ]),
                    'exists:\App\Models\Sigtap\Procedimento,id',
                ];

                if (is_null($procedimento)) {

                    continue;
                }

                $validation = new ProcedimentoValidationService($procedimento);

                $rules["procedimentos.{$i}.procedimento_id"] = array_merge(
                    $rules["procedimentos.{$i}.procedimento_id"],
                    [
                        $this->getDuplicatedValidator($this->procedimentos, $i),
                        $this->getOnValidCompetenciaValidator($validation),
                        $this->getOcupacaoValidator($validation),
                        $this->getSexoValidator($validation, $atendimento),
                        $this->getIdadeValidator($validation, $atendimento),
                    ]
                );

                if (is_numeric($params['quantidade'] ?? null)) {

                    $quantidade = $atendimento->procedimentos
                        ->where('procedimento_id', $procedimento->id)
                        ->sum('quantidade') + $params['quantidade'];

                    $rules["procedimentos.{$i}.procedimento_id"][] = $this->getQuantidadeValidator($validation, $quantidade);
                }

                $rules["procedimentos.{$i}.cid_principal_id"] = [
                    'nullable',
                    Rule::requiredIf(fn () => $procedimento->hasCidPrincipal),
                    'integer',
                    $procedimento->hasCidPrincipal
                        ? Rule::in($procedimento->cidsPrincipais()->pluck('id'))
                        : 'exists:\App\Models\Sigtap\Cid,id',
                ];

                $rules["procedimentos.{$i}.cid_secundario_id"] = [
                    'nullable',
                    'integer',
                    Rule::in($procedimento->cidsSecundarios()->pluck('id')),
                ];

                $rules["procedimentos.{$i}.quantidade"] = [
                    'required',
                    'integer',
                    'min:1',
                ];
            }
        }

        return $rules;
    }

    private function getPostPedidoExameRules($atendimento)
    {
        $rules = [
            'pedidos_exames' => [
                'nullable',
                'array',
            ],
        ];

        if ((is_array($this->pedidos_exames) ?? null)) {

            $rules = array_merge($rules, [
                'pedidos_exames.urgente' => [
                    'required',
                    'boolean',
                ],
                'pedidos_exames.justificativa' => [
                    'nullable',
                    'string',
                    'max:100',
                ],
                'pedidos_exames.exames' => [
                    'required',
                    'array',
                ],
                'pedidos_exames.exames.*.exame_id' => [
                    'required',
                    'distinct',
                    'integer',
                    'exists:\App\Models\Parametrizacao\Exame\Exame,id'
                ],
                'pedidos_exames.exames.*.observacao' => [
                    'nullable',
                    'string',
                    'max:1000'
                ],
            ]);
        }

        return $rules;
    }

    private function getPostServicosEnfermagemRules($atendimento)
    {
        $rules = [
            'servicos_enfermagem' => [
                'nullable',
                'array',
            ],
        ];

        if (is_array($this->servicos_enfermagem ?? null)) {

            foreach ($this->servicos_enfermagem as $i => $params) {

                $rules["servicos_enfermagem.{$i}.observacoes"] = [
                    'nullable',
                    'string',
                    'max:100'
                ];

                $rules["servicos_enfermagem.{$i}.procedimento_id"] = [
                    'required',
                    'integer',
                    'exists:\App\Models\Sigtap\Procedimento,id',
                ];

                $procedimento = is_numeric($params['procedimento_id'] ?? null)
                    ? Procedimento::find($params['procedimento_id'])
                    : null;

                if (is_null($procedimento)) {

                    continue;
                }

                $validation = new ProcedimentoValidationService($procedimento);

                $quantidade = $atendimento->procedimentos
                    ->where('procedimento_id', $procedimento->id)
                    ->sum('quantidade') + 1;

                $rules["servicos_enfermagem.{$i}.procedimento_id"] = [
                    $this->getOnValidCompetenciaValidator($validation),
                    $this->getSexoValidator($validation, $atendimento),
                    $this->getIdadeValidator($validation, $atendimento),
                    $this->getQuantidadeValidator($validation, $quantidade),
                ];
            }
        }

        return $rules;
    }

    private function getDuplicatedValidator($procedimentos, $index)
    {
        return function ($attribute, $value, $fail) use ($procedimentos, $index) {

            foreach ($procedimentos as $j => $params) {

                if ($index === $j || !isset($params['procedimento_id'])) {

                    continue;
                }

                if ($value == $params['procedimento_id']) {

                    $fail('O campo ' . $attribute . ' campo tem um valor duplicado.');
                }
            }
        };
    }

    private function getOnValidCompetenciaValidator($validation)
    {
        return function ($attribute, $value, $fail) use ($validation) {

            if (!$validation->isOnValidCompetencia()) {

                $fail('Competência do ' . $attribute . ' inválida.');
            }
        };
    }

    private function getOcupacaoValidator($validation)
    {
        return function ($attribute, $value, $fail) use ($validation) {

            $ocupacao = Lotacao::find(auth()->payload()->get('lotacao_id'))->ocupacao;

            if (!$validation->isOcupacaoValid($ocupacao)) {

                $fail($attribute . ' não permitido para o CBO do médico.');
            }
        };
    }

    private function getSexoValidator($validation, $atendimento)
    {
        return function($attribute, $value, $fail) use ($validation, $atendimento)
        {
            if (!$validation->isSexoValid($atendimento->faa->paciente->cidadao->sexo)) {

                $fail($attribute . ' não permitido para o sexo do paciente.');
            }
        };
    }

    private function getIdadeValidator($validation, $atendimento)
    {
        return function ($attribute, $value, $fail) use ($validation, $atendimento) {

            if (!$atendimento->faa->paciente->is_desconhecido
                && !$validation->isIdadeValid($atendimento->faa->paciente->cidadao->idade['anos'])
            ) {

                $fail($attribute . ' não permitido para a idade do paciente.');
            }
        };
    }

    private function getQuantidadeValidator($validation, $quantidade)
    {
        return function ($attribute, $value, $fail) use ($validation, $quantidade) {

            if (!$validation->isQuantidadeValid($quantidade)) {

                $fail('Quantidade máxima atingida para o '. $attribute);
            }
        };
    }

    private function getPostDesfechoRules($atendimento)
    {
        $rules = [
            'desfecho' => [
                'nullable',
                'array'
            ],
            'desfecho.id' => [
                'nullable',
                'integer',
                Rule::in(
                    Desfecho::ALTA_MEDICA,
                    Desfecho::EVASAO,
                    Desfecho::ENCAMINHAMENTO_HOSPITALAR,
                    Desfecho::OBITO,
                ),
                'exists:\App\Models\ProntoAtendimento\Atendimento\Desfecho,id',
            ],
            'desfecho.evasao' => [
                'nullable',
                'required_if:desfecho.id,' . Desfecho::EVASAO,
                'array',
            ],
            'desfecho.evasao.motivo' => [
                'nullable',
                'required_if:desfecho.id,' . Desfecho::EVASAO,
                'string',
                'max:200'
            ],
            'desfecho.encaminhamento_hospitalar' => [
                'nullable',
                'array',
            ],
            'desfecho.encaminhamento_hospitalar.unidade_id' => [
                'nullable',
                'integer',
                'exists:\App\Models\Cadastro\Estabelecimento\Unidade,id',
            ],
            'desfecho.encaminhamento_hospitalar.unidade_nome' => [
                'nullable',
                'string',
                'max:100',
            ],
            'desfecho.encaminhamento_hospitalar.quarto' => [
                'nullable',
                'string',
                'max:3',
            ],
            'desfecho.encaminhamento_hospitalar.leito' => [
                'nullable',
                'string',
                'max:3',
            ],
            'desfecho.encaminhamento_hospitalar.cid_id' => [
                'nullable',
                'integer',
                'exists:\App\Models\Sigtap\Cid,id',
            ],
            'desfecho.encaminhamento_hospitalar.medico_hospitalar' => [
                'nullable',
                'string',
                'max:150',
                new NomeCompleto,
            ],
            'desfecho.encaminhamento_hospitalar.observacoes' => [
                'nullable',
                'string',
                'max:3000',
            ],
            'desfecho.obito' => [
                'required_if:desfecho.id,' . Desfecho::OBITO,
                'array',
            ],
        ];

        if (is_array($this->desfecho['obito'] ?? null)) {

            $rules = array_merge($rules, [
                'desfecho.obito.obito_em' => [
                    'required',
                    'date_format:d/m/Y H:i',
                    $this->getObitoEmValidator($atendimento),
                ],
                'desfecho.obito.declaracao' => [
                    'nullable',
                    'string',
                    'min:8',
                    'max:13'
                ],
                'desfecho.obito.causa' => [
                    'required',
                    'string',
                    'max:255'
                ],
                'desfecho.obito.cid_id' => [
                    'required',
                    'integer',
                    'exists:\App\Models\Sigtap\Cid,id'
                ]
            ]);
        }

        return $rules;
    }

    private function getPostFinalizacaoRules($atendimento, $raatObrigatorio)
    {
        $rules = [
            'finalizacao' => [
                'nullable',
                'array',
            ],
        ];

        return array_merge(
            $rules,
            $this->getPostFinalizacaoDesfechoRules($atendimento)
        );
    }

    private function getPostFinalizacaoDesfechoRules($atendimento)
    {
        $rules = [
            'finalizacao.desfecho_id' => [
                Rule::requiredIf(fn () => $this->hasFinalizacao()),
                'integer',
                'exists:\App\Models\ProntoAtendimento\Atendimento\Desfecho,id',
            ],
            'finalizacao.evasao' => [
                'nullable',
                'required_if:finalizacao.desfecho_id,' . Desfecho::EVASAO,
                'array',
            ],
            'finalizacao.evasao.motivo' => [
                'nullable',
                'required_if:finalizacao.desfecho_id,' . Desfecho::EVASAO,
                'string',
                'max:200'
            ],
            'finalizacao.encaminhamento_hospitalar' => [
                'nullable',
                'required_if:finalizacao.desfecho_id,' . Desfecho::ENCAMINHAMENTO_HOSPITALAR,
                'array',
            ],
            'finalizacao.encaminhamento_hospitalar.unidade_id' => [
                'nullable',
                Rule::requiredIf(fn () =>
                    $this->finalizacao &&
                    $this->finalizacao['desfecho_id'] === Desfecho::ENCAMINHAMENTO_HOSPITALAR &&
                    $this->finalizacao['encaminhamento_hospitalar']['unidade_nome'] === null
                ),
                'integer',
                'exists:\App\Models\Cadastro\Estabelecimento\Unidade,id',
            ],
            'finalizacao.encaminhamento_hospitalar.unidade_nome' => [
                'nullable',
                Rule::requiredIf(fn () =>
                    $this->finalizacao &&
                    $this->finalizacao['desfecho_id'] === Desfecho::ENCAMINHAMENTO_HOSPITALAR &&
                    $this->finalizacao['encaminhamento_hospitalar']['unidade_id'] === null
                ),
                'string',
                'max:100',
            ],
            'finalizacao.encaminhamento_hospitalar.quarto' => [
                'nullable',
                'string',
                'max:3',
            ],
            'finalizacao.encaminhamento_hospitalar.leito' => [
                'nullable',
                'string',
                'max:3',
            ],
            'finalizacao.encaminhamento_hospitalar.cid_id' => [
                'nullable',
                'integer',
                'exists:\App\Models\Sigtap\Cid,id',
            ],
            'finalizacao.encaminhamento_hospitalar.medico_hospitalar' => [
                'nullable',
                'string',
                'max:150',
            ],
            'finalizacao.encaminhamento_hospitalar.observacoes' => [
                'nullable',
                'string',
                'max:3000',
            ],
            'finalizacao.obito' => [
                'required_if:finalizacao.desfecho_id,' . Desfecho::OBITO,
                'array',
            ],
        ];

        if (is_array($this->finalizacao['obito'] ?? null)) {

            $rules = array_merge($rules, [
                'finalizacao.obito.obito_em' => [
                    'required',
                    'date_format:d/m/Y H:i',
                    $this->getObitoEmValidator($atendimento),
                ],
                'finalizacao.obito.declaracao' => [
                    'nullable',
                    'string',
                    'min:8',
                    'max:13'
                ],
                'finalizacao.obito.causa' => [
                    'required',
                    'string',
                    'max:255'
                ],
                'finalizacao.obito.cid_id' => [
                    'required',
                    'integer',
                    'exists:\App\Models\Sigtap\Cid,id'
                ]
            ]);
        }

        return $rules;
    }

    private function hasFinalizacao()
    {
        return isset($this->finalizacao);
    }

    private function getObitoEmValidator($atendimento)
    {
        return function ($attribute, $value, $fail) use ($atendimento) {

            if (!$atendimento->faa->paciente->cidadao->data_nascimento) {

                return;
            }

            $dataAtual = Carbon::today();
            $dataNascimento = $atendimento->faa->paciente->cidadao->data_nascimento;
            $dataObito = Carbon::createFromFormat('d/m/Y H:i', $value);
            $diffObitoDataNascimento = $dataNascimento->diffInDays($dataObito, false);
            $diffObitoDataAtual = $dataAtual->diffInDays($dataObito, false);

            if ($diffObitoDataNascimento < 0 || $diffObitoDataAtual > 0) {

                $fail("A data inserida deve ser entre a data de nascimento {$dataNascimento->format('d/m/Y')} e a data atual.");
            }
        };
    }

    private function getCentroCustoLogado()
    {
        return CentroCusto::findOrFail(auth()->payload()->get('centro_custo_id'));
    }
}