<?php

namespace App\Services\Apac;

use App\Enums\Ambulatorio\AcompanhamentoOciMotivoEncerramento;
use App\Enums\Ambulatorio\AtendimentoSoapSolicitacaoExameItemStatus;
use App\Enums\Apac\CaraterAtendimento as ApacCaraterAtendimento;
use App\Enums\Apac\Tipo as ApacTipo;
use App\Enums\Cadastro\EtapaClinica;
use App\Enums\ExameLaboratorial\StatusAgendamento;
use App\Enums\Regulacao\StatusTipo;
use App\Enums\Sigtap\Detalhe;
use App\Enums\Sigtap\Registro;
use App\Exceptions\Apac\ProcedimentoSecundarioSemOcupacaoException;
use App\Models\Ambulatorio\AcompanhamentoOci;
use App\Models\Ambulatorio\AcompanhamentoOciProcedimentoRealizado;
use App\Models\Ambulatorio\AtendimentoProcedimento as AmbulatorioAtendimentoProcedimento;
use App\Models\Apac\CaraterAtendimento;
use App\Models\Apac\FonteOrcamentaria;
use App\Models\Apac\MotivoSaidaPermanencia;
use App\Models\Apac\SolicitacaoAutorizacao;
use App\Models\Apac\Tipo;
use App\Models\Apac\TipoAtendimento;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Paciente;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\ExameImagem\Fechamento\Faturamento;
use App\Models\ExameLaboratorial\AgendamentoExame\AgendamentoExame;
use App\Models\Sigtap\Cid;
use App\Models\Sigtap\Classificacao;
use App\Models\Sigtap\Competencia;
use App\Models\Sigtap\Ocupacao;
use App\Models\Sigtap\Procedimento;
use App\Models\Sigtap\Servico;
use App\Rules\Cnpj;
use App\Rules\Cns;
use App\Services\Service;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;

class ProcedimentoService extends Service
{
    public static function datatable()
    {
        return DB::table('apac_solicitacao_autorizacao AS solicitacao_autorizacao')
            ->join('sigtap.competencia AS competencia', 'competencia.id', 'solicitacao_autorizacao.competencia_id')
            ->join('cadastro_unidade AS unidade_executante', 'unidade_executante.id', 'solicitacao_autorizacao.unidade_executante_id')
            ->join('cadastro_paciente AS paciente', 'paciente.id', 'solicitacao_autorizacao.paciente_id')
            ->join('cadastro_cidadao AS paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
            ->join('sigtap.procedimento AS procedimento_principal', 'procedimento_principal.id', 'solicitacao_autorizacao.procedimento_principal_id')
            ->select(
                'solicitacao_autorizacao.id',
                'unidade_executante.nome_fantasia AS unidade_executante_nome_fantasia',
                'competencia.valor AS competencia_valor',
                DB::raw("DATE_FORMAT(solicitacao_autorizacao.data_processamento, '%d/%m/%Y') AS data_processamento"),
                'solicitacao_autorizacao.numero_apac',
                'paciente_cidadao.nome AS paciente_nome',
                'procedimento_principal.codigo AS procedimento_principal_codigo',
                DB::raw("IF(solicitacao_autorizacao.exportacao_id IS NULL, FALSE, TRUE) as exportado")
            );
    }

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

            case 'geracao':
            case 'exclusao': {

                return [
                    'form' => self::getGeracaoExclusaoFormData(),
                    'model' => self::getGeracaoExclusaoModelData(),
                ];
            }
            case 'cadastro': {

                return [
                    'additionals' => self::getCadastroAdditionalsData(),
                    'form' => self::getCadastroFormData(),
                    'model' => self::getCadastroModelData(),
                ];
            }
        }
    }

    public static function edit($id)
    {
        $solicitacaoAutorizacao = SolicitacaoAutorizacao::findOrFail($id);

        return [
            'additionals' => self::getCadastroAdditionalsData(),
            'form' => self::getCadastroFormData(),
            'model' => self::getCadastroModelData($solicitacaoAutorizacao),
        ];
    }

    private static function getGeracaoExclusaoFormData()
    {
        return [
            'unidades' => self::getUnidades(),
            'competencias' => self::getCompetencias(),
        ];
    }

    private static function getGeracaoExclusaoModelData()
    {
        return [
            'unidade_executante_id' => null,
            'competencia_id' => null,
        ];
    }

    private static function getCadastroAdditionalsData()
    {
        return [
            'data_atual' => Carbon::today()->format('d/m/Y'),
        ];
    }

    private static function getCadastroFormData()
    {
        return [
            'unidades' => self::getUnidades(),
            'competencias' => self::getCompetencias(),
            'tipos_atendimento' => self::getTiposAtendimento(),
            'tipos_apac' => self::getTiposApac(),
            'motivos_saida_permanencia' => self::getMotivosSaidaPermanencia(),
            'carateres_atendimento' => self::getCarateresAtendimento(),
            'fontes_orcamentarias' => self::getFontesOrcamentarias(),
        ];
    }

    private static function getUnidades()
    {
        return DB::table('cadastro_unidade AS unidade')
            ->whereNull('unidade.deleted_at')
            ->whereNotNull('unidade.cnes')
            ->whereRaw("TRIM(unidade.cnes) <> ''")
            ->select(
                'unidade.id',
                'unidade.nome_fantasia'
            )
            ->orderBy('unidade.nome_fantasia')
            ->get();
    }

    private static function getCompetencias()
    {
        return DB::table('sigtap.competencia AS competencia')
            ->select(
                'competencia.id',
                'competencia.valor'
            )
            ->orderByDesc('valor')
            ->take(4)
            ->get();
    }

    private static function getTiposAtendimento()
    {
        return DB::table('apac_tipo_atendimento AS tipo_atendimento')
            ->select(
                'tipo_atendimento.id',
                'tipo_atendimento.nome'
            )
            ->orderBy('tipo_atendimento.nome')
            ->get();
    }

    private static function getTiposApac()
    {
        return DB::table('apac_tipo AS tipo')
            ->select(
                'tipo.id',
                'tipo.nome'
            )
            ->orderBy('tipo.nome')
            ->get();
    }

    private static function getMotivosSaidaPermanencia()
    {
        return DB::table('apac_motivo_saida_permanencia AS motivo')
            ->select(
                'motivo.id',
                'motivo.nome'
            )
            ->orderBy('motivo.nome')
            ->get();
    }

    private static function getCarateresAtendimento()
    {
        return DB::table('apac_carater_atendimento AS carater')
            ->select(
                'carater.id',
                'carater.nome'
            )
            ->orderBy('carater.nome')
            ->get();
    }

    private static function getFontesOrcamentarias()
    {
        return DB::table('apac_fonte_orcamentaria AS fonte')
            ->select(
                'fonte.id',
                'fonte.nome'
            )
            ->orderBy('fonte.nome')
            ->get();
    }

    private static function getCadastroModelData($solicitacaoAutorizacao = null)
    {
        return [
            'competencia_id' => $solicitacaoAutorizacao->competencia_id ?? null,
            'data_processamento' => isset($solicitacaoAutorizacao->data_processamento)
                ? $solicitacaoAutorizacao->data_processamento->format('d/m/Y') : null,
            'numero_apac' => $solicitacaoAutorizacao->numero_apac ?? null,
            'numero_apac_anterior' => $solicitacaoAutorizacao->numero_apac_anterior ?? null,
            'unidade_solicitante_id' => $solicitacaoAutorizacao->unidade_solicitante_id ?? null,
            'unidade_executante_id' => $solicitacaoAutorizacao->unidade_executante_id ?? null,
            'usuario_executante' => isset($solicitacaoAutorizacao->usuarioExecutante)
                ? [
                    'id' => $solicitacaoAutorizacao->usuarioExecutante->id,
                    'cidadao_nome' => $solicitacaoAutorizacao->usuarioExecutante->cidadao->nome,
                ]
                : null,
            'data_inicial_validade' => isset($solicitacaoAutorizacao->data_inicial_validade)
                ? $solicitacaoAutorizacao->data_inicial_validade->format('d/m/Y') : null,
            'data_final_validade' => isset($solicitacaoAutorizacao->data_final_validade)
                ? $solicitacaoAutorizacao->data_final_validade->format('d/m/Y') : null,
            'paciente' => is_null($solicitacaoAutorizacao)
                ? null
                : $solicitacaoAutorizacao->paciente()->with([
                    'cidadao.racaCor',
                    'cidadao.etniaIndigena',
                    'cidadao.paisNascimento',
                    'cadastroIndividual'
                ])->first(),
            'procedimento_principal' => isset($solicitacaoAutorizacao->procedimentoPrincipal)
                ? [
                    'id' => $solicitacaoAutorizacao->procedimentoPrincipal->id,
                    'codigo' => $solicitacaoAutorizacao->procedimentoPrincipal->codigo,
                    'nome' => $solicitacaoAutorizacao->procedimentoPrincipal->nome,
                    'quantidade_maxima_execucao' => $solicitacaoAutorizacao->procedimentoPrincipal->quantidade_maxima_execucao,
                    'has_cid_principal' => $solicitacaoAutorizacao->procedimentoPrincipal->has_cid_principal,
                    'atributos_complementares' => $solicitacaoAutorizacao->procedimentoPrincipal->detalhes()->pluck('codigo')
                ]
                : null,
            'procedimento_principal_ocupacao' => isset($solicitacaoAutorizacao->procedimentoPrincipalOcupacao)
                ? [
                    'id' => $solicitacaoAutorizacao->procedimentoPrincipalOcupacao->id,
                    'codigo' => $solicitacaoAutorizacao->procedimentoPrincipalOcupacao->codigo,
                    'nome' => $solicitacaoAutorizacao->procedimentoPrincipalOcupacao->nome,
                ]
                : null,
            'procedimento_principal_quantidade' => $solicitacaoAutorizacao->procedimento_principal_quantidade ?? null,
            'procedimento_principal_cnpj_cessao_credito' => isset($solicitacaoAutorizacao->procedimento_principal_cnpj_cessao_credito)
                ? MaskUtil::getCnpjMasked($solicitacaoAutorizacao->procedimento_principal_cnpj_cessao_credito)
                : null,
            'procedimento_principal_numero_nota_fiscal_cessao' => $solicitacaoAutorizacao->procedimento_principal_numero_nota_fiscal_cessao ?? null,
            'procedimento_principal_cid_principal' => isset($solicitacaoAutorizacao->procedimentoPrincipalCidPrincipal)
                ? [
                    'id' => $solicitacaoAutorizacao->procedimentoPrincipalCidPrincipal->id,
                    'codigo' => $solicitacaoAutorizacao->procedimentoPrincipalCidPrincipal->codigo,
                    'nome' => $solicitacaoAutorizacao->procedimentoPrincipalCidPrincipal->nome,
                ]
                : null,
            'procedimento_principal_cid_secundario' => isset($solicitacaoAutorizacao->procedimentoPrincipalCidSecundario)
                ? [
                    'id' => $solicitacaoAutorizacao->procedimentoPrincipalCidSecundario->id,
                    'codigo' => $solicitacaoAutorizacao->procedimentoPrincipalCidSecundario->codigo,
                    'nome' => $solicitacaoAutorizacao->procedimentoPrincipalCidSecundario->nome,
                ]
                : null,
            'procedimento_principal_servico' => isset($solicitacaoAutorizacao->procedimentoPrincipalServico)
                ? [
                    'id' => $solicitacaoAutorizacao->procedimentoPrincipalServico->id,
                    'nome' => $solicitacaoAutorizacao->procedimentoPrincipalServico->nome,
                ]
                : null,
            'procedimento_principal_classificacao' => isset($solicitacaoAutorizacao->procedimentoPrincipalClassificacao)
                ? [
                    'id' => $solicitacaoAutorizacao->procedimentoPrincipalClassificacao->id,
                    'nome' => $solicitacaoAutorizacao->procedimentoPrincipalClassificacao->nome,
                ]
                : null,
            'procedimento_principal_unidade_prestadora_terceiro_cnes' =>
                $solicitacaoAutorizacao->procedimento_principal_unidade_prestadora_terceiro_cnes ?? null,
            'cid_causa_associada' => isset($solicitacaoAutorizacao->cidCausaAssociada)
                ? [
                    'id' => $solicitacaoAutorizacao->cidCausaAssociada->id,
                    'codigo' => $solicitacaoAutorizacao->cidCausaAssociada->codigo,
                    'nome' => $solicitacaoAutorizacao->cidCausaAssociada->nome,
                ]
                : null,
            'motivo_saida_permanencia_id' => $solicitacaoAutorizacao->motivo_saida_permanencia_id ?? null,
            'data_ocorrencia' => isset($solicitacaoAutorizacao->data_ocorrencia)
                ? $solicitacaoAutorizacao->data_ocorrencia->format('d/m/Y') : null,
            'tipo_atendimento_id' => $solicitacaoAutorizacao->tipo_atendimento_id ?? null,
            'carater_atendimento_id' => $solicitacaoAutorizacao->carater_atendimento_id ?? null,
            'tipo_apac_id' => $solicitacaoAutorizacao->tipo_apac_id ?? null,
            'usuario_responsavel' => isset($solicitacaoAutorizacao->usuarioResponsavel)
                ? [
                    'id' => $solicitacaoAutorizacao->usuarioResponsavel->id,
                    'cidadao_nome' => $solicitacaoAutorizacao->usuarioResponsavel->cidadao->nome,
                ]
                : null,
            'data_solicitacao' => isset($solicitacaoAutorizacao->data_solicitacao)
                ? $solicitacaoAutorizacao->data_solicitacao->format('d/m/Y') : null,
            'usuario_autorizador_nome' => $solicitacaoAutorizacao->usuario_autorizador_nome ?? null,
            'usuario_autorizador_cns' => isset($solicitacaoAutorizacao->usuario_autorizador_cns)
                ? MaskUtil::getCnsMasked($solicitacaoAutorizacao->usuario_autorizador_cns)
                : null,
            'data_autorizacao' => isset($solicitacaoAutorizacao->data_autorizacao)
                ? $solicitacaoAutorizacao->data_autorizacao->format('d/m/Y') : null,
            'codigo_emissor' => $solicitacaoAutorizacao->codigo_emissor ?? null,
            'fonte_orcamentaria_id' => $solicitacaoAutorizacao->fonte_orcamentaria_id ?? null,
            'emenda_parlamentar' => $solicitacaoAutorizacao->emenda_parlamentar ?? false,
            'laudo_geral' => [
                'cid_principal' => isset($solicitacaoAutorizacao->laudoGeral->cidPrincipal)
                    ? [
                        'id' => $solicitacaoAutorizacao->laudoGeral->cidPrincipal->id,
                        'codigo' => $solicitacaoAutorizacao->laudoGeral->cidPrincipal->codigo,
                        'nome' => $solicitacaoAutorizacao->laudoGeral->cidPrincipal->nome,
                    ]
                    : null,
                'cid_secundario' => isset($solicitacaoAutorizacao->laudoGeral->cidSecundario)
                    ? [
                        'id' => $solicitacaoAutorizacao->laudoGeral->cidSecundario->id,
                        'codigo' => $solicitacaoAutorizacao->laudoGeral->cidSecundario->codigo,
                        'nome' => $solicitacaoAutorizacao->laudoGeral->cidSecundario->nome,
                    ]
                    : null,
                'data_identificacao_patologica' => isset($solicitacaoAutorizacao->laudoGeral->data_identificacao_patologica)
                    ? $solicitacaoAutorizacao->laudoGeral->data_identificacao_patologica->format('d/m/Y') : null,
            ],
            'procedimentos_secundarios' => is_null($solicitacaoAutorizacao)
                ? []
                : $solicitacaoAutorizacao->procedimentosSecundarios->map(fn ($procedimento) => [
                    'id' => $procedimento->id,
                    'saved' => true,
                    'procedimento' => [
                        'id' => $procedimento->procedimento->id,
                        'codigo' => $procedimento->procedimento->codigo,
                        'nome' => $procedimento->procedimento->nome,
                        'quantidade_maxima_execucao' => $procedimento->procedimento->quantidade_maxima_execucao,
                        'has_cid_principal' => $procedimento->procedimento->has_cid_principal,
                        'atributos_complementares' => $procedimento->procedimento->detalhes()->pluck('codigo')
                    ],
                    'ocupacao' => [
                        'id' => $procedimento->ocupacao->id,
                        'codigo' => $procedimento->ocupacao->codigo,
                        'nome' => $procedimento->ocupacao->nome,
                    ],
                    'quantidade' => $procedimento->quantidade,
                    'cnpj_cessao_credito' => isset($procedimento->cnpj_cessao_credito)
                        ? MaskUtil::getCnpjMasked($procedimento->cnpj_cessao_credito)
                        : null,
                    'numero_nota_fiscal_cessao' => $procedimento->numero_nota_fiscal_cessao,
                    'cid_principal' => isset($procedimento->cidPrincipal)
                        ? [
                            'id' => $procedimento->cidPrincipal->id,
                            'codigo' => $procedimento->cidPrincipal->codigo,
                            'nome' => $procedimento->cidPrincipal->nome,
                        ]
                        : null,
                    'cid_secundario' => isset($procedimento->cidSecundario)
                        ? [
                            'id' => $procedimento->cidSecundario->id,
                            'codigo' => $procedimento->cidSecundario->codigo,
                            'nome' => $procedimento->cidSecundario->nome,
                        ]
                        : null,
                    'servico' => isset($procedimento->servico)
                        ? [
                            'id' => $procedimento->servico->id,
                            'nome' => $procedimento->servico->nome,
                        ]
                        : null,
                    'classificacao' => $procedimento->classificacao
                        ? [
                            'id' => $procedimento->classificacao->id,
                            'nome' => $procedimento->classificacao->nome,
                        ]
                        : null,
                    'unidade_prestadora_terceiro_cnes' => $procedimento->unidade_prestadora_terceiro_cnes,
                ]),
            'exportado' => !is_null($solicitacaoAutorizacao->exportacao_id ?? null),
        ];
    }

    public static function store()
    {
        $response = null;

        DB::transaction(function() use (&$response) {

            switch (request()->origem) {

                case 'geracao': {

                    $response = self::storeProcedimentosAutomaticos();

                    break;
                }
                case 'cadastro': {

                    $response = self::storeProcedimentoManual();

                    break;
                }
            }
        });

        return $response;
    }

    private static function storeProcedimentosAutomaticos()
    {
        $competencia = Competencia::findOrFail(request()->competencia_id);

        DB::table('ambulatorio_atendimento_procedimento as atendimento_procedimento')
            ->join('ambulatorio_atendimento as atendimento', 'atendimento.id', 'atendimento_procedimento.atendimento_id')
            ->join('ambulatorio_agendamento as agendamento', 'agendamento.id', 'atendimento.agendamento_id')
            ->join('ambulatorio_jornada as jornada', 'jornada.id', 'agendamento.jornada_id')
            ->join('cadastro_lotacao as lotacao', 'lotacao.id', 'jornada.lotacao_id')
            ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
            ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'atendimento_procedimento.procedimento_id')
            ->join('sigtap.procedimento_registro as procedimento_registro', 'procedimento_registro.procedimento_id', 'procedimento.id')
            ->join('sigtap.registro as registro', 'registro.id', 'procedimento_registro.registro_id')
            ->whereNull('atendimento_procedimento.apac_solicitacao_autorizacao_id')
            ->where('infraestrutura.unidade_id', request()->unidade_executante_id)
            ->whereYear('jornada.data', Str::substr($competencia->valor, 0, 4))
            ->whereMonth('jornada.data', Str::substr($competencia->valor, 4, 2))
            ->where('registro.codigo', Registro::APAC_PROC_PRINCIPAL)
            ->select(
                DB::raw("'atendimento_procedimento' as origem"),
                'atendimento_procedimento.id',
                'atendimento_procedimento.procedimento_id',
                DB::raw("CAST(atendimento_procedimento.created_at AS DATE) as data"),
                'atendimento_procedimento.usuario_id',
                'atendimento_procedimento.cid_id',
                'atendimento_procedimento.ocupacao_id',
                'atendimento_procedimento.quantidade',
                'atendimento_procedimento.soap_id',
                'agendamento.paciente_id'
            )
            ->union(DB::table('ambulatorio_acompanhamento_oci as acompanhamento_oci')
                ->join(
                    'ambulatorio_acompanhamento_oci_etapa_clinica_concluida as etapa_clinica_concluida',
                    'etapa_clinica_concluida.acompanhamento_oci_id',
                    'acompanhamento_oci.id'
                )
                ->join('ambulatorio_atendimento_soap as soap', 'soap.id', 'etapa_clinica_concluida.soap_id')
                ->join('ambulatorio_atendimento as atendimento', 'atendimento.id', 'soap.atendimento_id')
                ->join('ambulatorio_agendamento as agendamento', 'agendamento.id', 'atendimento.agendamento_id')
                ->join('ambulatorio_jornada as jornada', 'jornada.id', 'agendamento.jornada_id')
                ->join('cadastro_lotacao as lotacao', 'lotacao.id', 'jornada.lotacao_id')
                ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                ->whereNull('acompanhamento_oci.apac_solicitacao_autorizacao_id')
                ->where('acompanhamento_oci.finalizado_motivo_encerramento_id', AcompanhamentoOciMotivoEncerramento::CONCLUIDO)
                ->whereNotNull('acompanhamento_oci.procedimento_oci_procedimento_id')
                ->whereYear('acompanhamento_oci.procedimento_oci_data', Str::substr($competencia->valor, 0, 4))
                ->whereMonth('acompanhamento_oci.procedimento_oci_data', Str::substr($competencia->valor, 4, 2))
                ->where('etapa_clinica_concluida.etapa_clinica_id', EtapaClinica::ENTRADA)
                ->where('infraestrutura.unidade_id', request()->unidade_executante_id)
                ->select(
                    DB::raw("'acompanhamento_oci' as origem"),
                    'acompanhamento_oci.id',
                    'acompanhamento_oci.procedimento_oci_procedimento_id as procedimento_id',
                    'acompanhamento_oci.procedimento_oci_data as data',
                    'acompanhamento_oci.procedimento_oci_usuario_id as usuario_id',
                    'acompanhamento_oci.procedimento_oci_cid_id as cid_id',
                    'acompanhamento_oci.procedimento_oci_ocupacao_id as ocupacao_id',
                    'acompanhamento_oci.procedimento_oci_quantidade as quantidade',
                    'soap.id as soap_id',
                    'acompanhamento_oci.paciente_id',
                )
            )
            ->get()
            ->each(function ($item) use ($competencia) {

                $acompanhamentoOci = DB::table('ambulatorio_acompanhamento_oci as acompanhamento_oci')
                    ->join('cadastro_lotacao as lotacao', 'lotacao.id', 'acompanhamento_oci.iniciado_lotacao_id')
                    ->join('cadastro_infraestrutura as infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('ambulatorio_acompanhamento_oci_etapa_clinica_concluida as etapa_concluida')
                        ->whereColumn('etapa_concluida.acompanhamento_oci_id', 'acompanhamento_oci.id')
                        ->where('etapa_concluida.soap_id', $item->soap_id)
                    )
                    ->select(
                        'acompanhamento_oci.id',
                        'acompanhamento_oci.oci_id',
                        DB::raw("CAST(acompanhamento_oci.iniciado_em AS DATE) as data_inicio"),
                        'acompanhamento_oci.motivo_saida_permanencia_id',
                        'infraestrutura.unidade_id',
                        'lotacao.usuario_id'
                    )
                    ->first();

                if ($acompanhamentoOci) {

                    $solicitacaoAutorizacao = SolicitacaoAutorizacao::create([
                        'competencia_id' => $competencia->id,
                        'data_processamento' => $item->data,
                        'unidade_solicitante_id' => $acompanhamentoOci->unidade_id,
                        'unidade_executante_id' => request()->unidade_executante_id,
                        'usuario_executante_id' => $item->usuario_id,
                        'data_inicial_validade' => $acompanhamentoOci->data_inicio,
                        'data_final_validade' => $item->data,
                        'paciente_id' => $item->paciente_id,
                        'procedimento_principal_id' => $item->procedimento_id,
                        'procedimento_principal_ocupacao_id' => $item->ocupacao_id,
                        'procedimento_principal_quantidade' => $item->quantidade,
                        'procedimento_principal_cid_principal_id' => $item->cid_id,
                        'motivo_saida_permanencia_id' => $acompanhamentoOci->motivo_saida_permanencia_id,
                        'data_ocorrencia' => $item->data,
                        'carater_atendimento_id' => ApacCaraterAtendimento::ELETIVO,
                        'tipo_apac_id' => ApacTipo::UNICA,
                        'usuario_responsavel_id' => $acompanhamentoOci->usuario_id,
                        'data_solicitacao' => $acompanhamentoOci->data_inicio,
                        'emenda_parlamentar' => false,
                        'is_automatico' => true,
                    ]);

                    $solicitacaoAutorizacao->laudoGeral()->create([
                        'cid_principal_id' => $item->cid_id
                    ]);

                    if ($item->origem === 'atendimento_procedimento') {

                        AmbulatorioAtendimentoProcedimento::where('id', $item->id)
                            ->update(['apac_solicitacao_autorizacao_id' => $solicitacaoAutorizacao->id]);
                    }
                    else if ($item->origem === 'acompanhamento_oci') {

                        AcompanhamentoOci::where('id', $item->id)
                            ->update(['apac_solicitacao_autorizacao_id' => $solicitacaoAutorizacao->id]);
                    }

                    $procedimentosSecundarios = self::getProcedimentosSecundariosOci($acompanhamentoOci, $competencia->id);

                    if ($procedimentosSecundarios->where('ocupacao_id', null)->isNotEmpty()) {

                        throw new ProcedimentoSecundarioSemOcupacaoException;
                    }

                    $procedimentosSecundarios->groupBy(function ($data) {
                            return $data->procedimento_id . '_' . $data->ocupacao_id;
                        })
                        ->each(function ($grouped) use ($solicitacaoAutorizacao) {

                            $first = $grouped->first();

                            $procedimentoSecundario = $solicitacaoAutorizacao->procedimentosSecundarios()->create([
                                'procedimento_id' => $first->procedimento_id,
                                'ocupacao_id' => $first->ocupacao_id,
                                'quantidade' => $grouped->sum('quantidade'),
                            ]);

                            $grouped->each(function ($data) use ($procedimentoSecundario) {

                                $data->origens->each(function ($origem) use ($procedimentoSecundario) {

                                    if ($origem->origem === 'exame_laboratorial') {

                                        AgendamentoExame::where('id', $origem->origem_id)
                                            ->update(['apac_procedimento_secundario_id' => $procedimentoSecundario->id]);
                                    }
                                    else if ($origem->origem === 'exame_imagem') {

                                        Faturamento::where('id', $origem->origem_id)
                                            ->update(['apac_procedimento_secundario_id' => $procedimentoSecundario->id]);
                                    }
                                    else if ($origem->origem === 'ambulatorio') {

                                        AmbulatorioAtendimentoProcedimento::where('id', $origem->origem_id)
                                            ->update(['apac_procedimento_secundario_id' => $procedimentoSecundario->id]);
                                    }
                                    else if ($origem->origem === 'procedimento_realizado') {

                                        AcompanhamentoOciProcedimentoRealizado::where('id', $origem->origem_id)
                                            ->update(['apac_procedimento_secundario_id' => $procedimentoSecundario->id]);
                                    }
                                });
                            });
                        });
                }
            });
    }

    private static function getProcedimentosSecundariosOci($acompanhamentoOci, $competenciaId)
    {
        $procedimentosSecundarios = collect();

        $procedimentosPrimariosOci = DB::table('cadastro_oci_procedimento_primario AS procedimento_primario')
            ->where('procedimento_primario.oci_id', $acompanhamentoOci->oci_id)
            ->select('procedimento_primario.procedimento_codigo')
            ->get()
            ->pluck('procedimento_codigo')
            ->all();

        $procedimentosSecundariosOci = DB::table('cadastro_oci_procedimento_secundario AS procedimento_secundario')
            ->where('procedimento_secundario.oci_id', $acompanhamentoOci->oci_id)
            ->select('procedimento_secundario.procedimento_codigo')
            ->get()
            ->pluck('procedimento_codigo')
            ->all();

        $procedimentosOci = array_merge($procedimentosPrimariosOci, $procedimentosSecundariosOci);

        $addProcedimento = function ($data) use ($procedimentosSecundarios) {

            $procedimentoId = (int) $data->procedimento_id;
            $ocupacaoId = is_null($data->ocupacao_id) ? null : ((int) $data->ocupacao_id);

            $procedimentoSecundario = $procedimentosSecundarios
                ->where('procedimento_id', $procedimentoId)
                ->where('ocupacao_id', $ocupacaoId)
                ->first();

            if (is_null($procedimentoSecundario)) {

                $procedimentoSecundario = (object) [
                    'procedimento_id' => $procedimentoId,
                    'ocupacao_id' => $ocupacaoId,
                    'quantidade' => $data->quantidade,
                    'origens' => collect(),
                ];

                $procedimentosSecundarios->push($procedimentoSecundario);
            }
            else {

                $procedimentoSecundario->quantidade += $data->quantidade;
            }

            $procedimentoSecundario->origens->push((object) [
                'origem' => $data->origem,
                'origem_id' => $data->origem_id,
            ]);
        };

        DB::table('ambulatorio_atendimento_soap_solicitacao_exame_item as solicitacao_exame_item')
            ->join('parametrizacao_exame as exame', 'exame.id', 'solicitacao_exame_item.exame_id')
            ->join('sigtap.procedimento as procedimento', fn ($j) => $j
                ->on('procedimento.codigo', 'exame.codigo')
                ->where('procedimento.competencia_id', $competenciaId)
            )
            ->join(
                'ambulatorio_atendimento_soap_solicitacao_exame as solicitacao_exame',
                'solicitacao_exame.id',
                'solicitacao_exame_item.solicitacao_exame_id'
            )
            ->join('ambulatorio_atendimento_soap as soap', 'soap.id', 'solicitacao_exame.soap_id')
            ->where('soap.acompanhamento_oci_id', $acompanhamentoOci->id)
            ->whereIn('exame.codigo', $procedimentosOci)
            ->select(
                'solicitacao_exame_item.id',
                'procedimento.id as procedimento_id',
                'solicitacao_exame_item.ocupacao_executora_id',
                'solicitacao_exame_item.status_id'
            )
            ->get()
            ->each(function ($solicitacaoExameItem) use ($addProcedimento) {

                $exameLaboratorial = DB::table('exame_laboratorial_agendamento_exame as agendamento_exame')
                    ->join('exame_laboratorial_agendamento as agendamento', 'agendamento.id', 'agendamento_exame.agendamento_id')
                    ->where('agendamento_exame.soap_solicitacao_exame_item_id', $solicitacaoExameItem->id)
                    ->whereIn('agendamento_exame.status_id', [
                        StatusAgendamento::REALIZADO,
                        StatusAgendamento::PENDENTE_ASSINATURA,
                        StatusAgendamento::ASSINADO,
                        StatusAgendamento::PENDENTE_ENTREGA,
                        StatusAgendamento::ENTREGUE,
                    ])
                    ->select(
                        DB::raw("'exame_laboratorial' as origem"),
                        'agendamento_exame.id as origem_id',
                        'agendamento_exame.procedimento_id',
                        'agendamento.laboratorio_ocupacao_id as ocupacao_id',
                        'agendamento_exame.quantidade'
                    )
                    ->first();

                if (!is_null($exameLaboratorial)) {

                    $addProcedimento($exameLaboratorial);

                    return;
                }

                $exameImagem = DB::table('exame_imagem_agendamento_exame as agendamento_exame')
                    ->join('exame_imagem_fechamento_faturamento as fechamento', 'fechamento.agendamento_exame_id', 'agendamento_exame.id')
                    ->where('agendamento_exame.soap_solicitacao_exame_item_id', $solicitacaoExameItem->id)
                    ->select(
                        DB::raw("'exame_imagem' as origem"),
                        'fechamento.id as origem_id',
                        'fechamento.procedimento_id',
                        'fechamento.ocupacao_id',
                        'fechamento.quantidade'
                    )
                    ->first();

                if (!is_null($exameImagem)) {

                    $addProcedimento($exameImagem);

                    return;
                }

                $exameLaboratorialReguladoInterno = DB::table('regulacao_solicitacao_item as solicitacao_item')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'solicitacao_item.solicitacao_id')
                    ->join('regulacao_status as status', 'status.id', 'solicitacao.status_id')
                    ->join('exame_laboratorial_agendamento as agendamento', 'agendamento.regulacao_solicitacao_id', 'solicitacao.id')
                    ->join('exame_laboratorial_agendamento_exame as agendamento_exame', fn ($j) => $j
                        ->on('agendamento_exame.agendamento_id', 'agendamento.id')
                        ->whereColumn('agendamento_exame.exame_id', 'solicitacao_item.exame_id')
                    )
                    ->where('solicitacao_item.soap_solicitacao_item_id', $solicitacaoExameItem->id)
                    ->where('status.tipo_id', StatusTipo::REALIZADO)
                    ->select(
                        DB::raw("'exame_laboratorial' as origem"),
                        'agendamento_exame.id as origem_id',
                        'agendamento_exame.procedimento_id',
                        'agendamento.laboratorio_ocupacao_id as ocupacao_id',
                        'agendamento_exame.quantidade'
                    )
                    ->first();

                if (!is_null($exameLaboratorialReguladoInterno)) {

                    $addProcedimento($exameLaboratorialReguladoInterno);

                    return;
                }

                $exameImagemReguladoInterno = DB::table('regulacao_solicitacao_item as solicitacao_item')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'solicitacao_item.solicitacao_id')
                    ->join('regulacao_status as status', 'status.id', 'solicitacao.status_id')
                    ->join('exame_imagem_agendamento as agendamento', 'agendamento.regulacao_solicitacao_id', 'solicitacao.id')
                    ->join('exame_imagem_agendamento_exame as agendamento_exame', fn ($j) => $j
                        ->on('agendamento_exame.agendamento_id', 'agendamento.id')
                        ->whereColumn('agendamento_exame.exame_id', 'solicitacao_item.exame_id')
                    )
                    ->join('exame_imagem_fechamento_faturamento as fechamento', 'fechamento.agendamento_exame_id', 'agendamento_exame.id')
                    ->where('solicitacao_item.soap_solicitacao_item_id', $solicitacaoExameItem->id)
                    ->where('status.tipo_id', StatusTipo::REALIZADO)
                    ->select(
                        DB::raw("'exame_imagem' as origem"),
                        'fechamento.id as origem_id',
                        'fechamento.procedimento_id',
                        'fechamento.ocupacao_id',
                        'fechamento.quantidade'
                    )
                    ->first();

                if (!is_null($exameImagemReguladoInterno)) {

                    $addProcedimento($exameImagemReguladoInterno);

                    return;
                }

                $exameReguladoExterno = DB::table('regulacao_solicitacao_item as solicitacao_item')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'solicitacao_item.solicitacao_id')
                    ->join('regulacao_status as status', 'status.id', 'solicitacao.status_id')
                    ->where('solicitacao_item.soap_solicitacao_item_id', $solicitacaoExameItem->id)
                    ->where('status.tipo_id', StatusTipo::REALIZADO)
                    ->whereNotNull('solicitacao.prestador_externo_id')
                    ->select(
                        'solicitacao.ocupacao_executora_id as ocupacao_id'
                    )
                    ->first();

                if ($exameReguladoExterno) {

                    $addProcedimento((object) [
                        'origem' => 'externo_regulado',
                        'origem_id' => null,
                        'procedimento_id' => $solicitacaoExameItem->procedimento_id,
                        'ocupacao_id' => $exameReguladoExterno->ocupacao_id,
                        'quantidade' => 1
                    ]);

                    return;
                }

                if ($solicitacaoExameItem->status_id === AtendimentoSoapSolicitacaoExameItemStatus::REALIZADO) {

                    $addProcedimento((object) [
                        'origem' => 'externo_nao_regulado',
                        'origem_id' => null,
                        'procedimento_id' => $solicitacaoExameItem->procedimento_id,
                        'ocupacao_id' => $solicitacaoExameItem->ocupacao_executora_id,
                        'quantidade' => 1
                    ]);

                    return;
                }
            });

        DB::table('ambulatorio_atendimento_procedimento as atendimento_procedimento')
            ->join('sigtap.procedimento as procedimento', 'procedimento.id', 'atendimento_procedimento.procedimento_id')
            ->join('sigtap.procedimento as procedimento_atual', fn ($j) => $j
                ->on('procedimento_atual.codigo', 'procedimento.codigo')
                ->where('procedimento_atual.competencia_id', $competenciaId)
            )
            ->join('ambulatorio_atendimento_soap as soap', 'soap.id', 'atendimento_procedimento.soap_id')
            ->where('soap.acompanhamento_oci_id', $acompanhamentoOci->id)
            ->whereIn('procedimento.codigo', $procedimentosOci)
            ->select(
                DB::raw("'ambulatorio' as origem"),
                'atendimento_procedimento.id as origem_id',
                'procedimento_atual.id as procedimento_id',
                'atendimento_procedimento.ocupacao_id',
                'atendimento_procedimento.quantidade'
            )
            ->get()
            ->each(function ($atendimentoProcedimento) use ($addProcedimento) {

                $addProcedimento($atendimentoProcedimento);
            });

        DB::table('ambulatorio_acompanhamento_oci_procedimento_realizado as procedimento_realizado')
            ->where('procedimento_realizado.acompanhamento_oci_id', $acompanhamentoOci->id)
            ->select(
                DB::raw("'procedimento_realizado' as origem"),
                'procedimento_realizado.id as origem_id',
                'procedimento_realizado.procedimento_id',
                'procedimento_realizado.ocupacao_executora_id as ocupacao_id',
                DB::raw("1 as quantidade")
            )
            ->get()
            ->each(function ($procedimentoRealizado) use ($addProcedimento) {

                $addProcedimento($procedimentoRealizado);
            });

        return $procedimentosSecundarios;
    }

    private static function storeProcedimentoManual()
    {
        self::validate();

        $solicitacaoAutorizacao = new SolicitacaoAutorizacao();

        $params = self::getSaveParams();

        $solicitacaoAutorizacao->fill($params);
        $solicitacaoAutorizacao->is_automatico = false;
        $solicitacaoAutorizacao->save();

        if (!self::procedimentoExigeDadosComplementares($params['procedimento_principal_id'])) {

            $solicitacaoAutorizacao->laudoGeral()->create($params['laudo_geral']);
        }

        $solicitacaoAutorizacao->procedimentosSecundarios()->createMany($params['procedimentos_secundarios']);

        return $solicitacaoAutorizacao;
    }

    public static function update($id)
    {
        $solicitacaoAutorizacao = SolicitacaoAutorizacao::findOrFail($id);

        self::validate();

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

            $params = self::getSaveParams();

            $solicitacaoAutorizacao->update($params);

            if (!self::procedimentoExigeDadosComplementares($params['procedimento_principal_id'])) {

                if ($solicitacaoAutorizacao->laudoGeral) {

                    $solicitacaoAutorizacao->laudoGeral()->update($params['laudo_geral']);
                }
                else {

                    $solicitacaoAutorizacao->laudoGeral()->create($params['laudo_geral']);
                }
            }
            else if ($solicitacaoAutorizacao->laudoGeral) {

                $solicitacaoAutorizacao->laudoGeral->delete();
            }

            $solicitacaoAutorizacao->procedimentosSecundarios()
                ->whereNotIn('id', collect($params['procedimentos_secundarios'])->filter(fn ($p) => !is_null($p['id']))->pluck('id'))
                ->get()
                ->each(function ($procedimentoSecundario) {

                    AgendamentoExame::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                        ->update(['apac_procedimento_secundario_id' => null]);

                    Faturamento::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                        ->update(['apac_procedimento_secundario_id' => null]);

                    AmbulatorioAtendimentoProcedimento::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                        ->update(['apac_procedimento_secundario_id' => null]);

                    $procedimentoSecundario->delete();
                });

            foreach ($params['procedimentos_secundarios'] as $procedimentoParams) {

                $solicitacaoAutorizacao->procedimentosSecundarios()->updateOrCreate(
                    ['id' => $procedimentoParams['id']],
                    $procedimentoParams
                );
            }
        });

        return $solicitacaoAutorizacao->fresh();
    }

    private static function validate()
    {
        return request()->validate([
            'competencia_id' => [
                'required',
                'integer',
                Rule::exists(Competencia::class, 'id'),
            ],
            'data_processamento' => [
                'required',
                'date_format:d/m/Y'
            ],
            'numero_apac' => [
                'required',
                'digits:13',
            ],
            'numero_apac_anterior' => [
                'nullable',
                'digits:13',
            ],
            'unidade_solicitante_id' => [
                'nullable',
                'integer',
                Rule::exists(Unidade::class, 'id'),
            ],
            'unidade_executante_id' => [
                'required',
                'integer',
                Rule::exists(Unidade::class, 'id'),
            ],
            'usuario_executante_id' => [
                'required',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'data_inicial_validade' => [
                'required',
                'date_format:d/m/Y',
                'before_or_equal:data_final_validade',
            ],
            'data_final_validade' => [
                'required',
                'date_format:d/m/Y',
                'after_or_equal:data_inicial_validade',
            ],
            'paciente_id' => [
                'required',
                'integer',
                Rule::exists(Paciente::class, 'id'),
            ],
            'procedimento_principal_id' => [
                'required',
                'integer',
                Rule::exists(Procedimento::class, 'id'),
            ],
            'procedimento_principal_ocupacao_id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'procedimento_principal_quantidade' => [
                'required',
                'integer',
                'min:1',
            ],
            'procedimento_principal_cnpj_cessao_credito' => [
                'nullable',
                'digits:14',
                new Cnpj,
            ],
            'procedimento_principal_numero_nota_fiscal_cessao' => [
                'nullable',
                'string',
                'max:6',
            ],
            'procedimento_principal_cid_principal_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'procedimento_principal_cid_secundario_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'procedimento_principal_servico_id' => [
                'nullable',
                'integer',
                Rule::exists(Servico::class, 'id'),
            ],
            'procedimento_principal_classificacao_id' => [
                'nullable',
                'integer',
                Rule::exists(Classificacao::class, 'id'),
            ],
            'procedimento_principal_unidade_prestadora_terceiro_cnes' => [
                'nullable',
                'string',
                'between:7,7',
            ],
            'cid_causa_associada_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'motivo_saida_permanencia_id' => [
                'required',
                'integer',
                Rule::exists(MotivoSaidaPermanencia::class, 'id'),
            ],
            'data_ocorrencia' => [
                'nullable',
                'date_format:d/m/Y'
            ],
            'tipo_atendimento_id' => [
                'nullable',
                'integer',
                Rule::exists(TipoAtendimento::class, 'id'),
            ],
            'carater_atendimento_id' => [
                'required',
                'integer',
                Rule::exists(CaraterAtendimento::class, 'id'),
            ],
            'tipo_apac_id' => [
                'required',
                'integer',
                Rule::exists(Tipo::class, 'id')
            ],
            'usuario_responsavel_id' => [
                'required',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'data_solicitacao' => [
                'required',
                'date_format:d/m/Y',
            ],
            'usuario_autorizador_nome' => [
                'required',
                'string',
                'max:30'
            ],
            'usuario_autorizador_cns' => [
                'required',
                'digits:15',
                new Cns,
            ],
            'data_autorizacao' => [
                'required',
                'date_format:d/m/Y',
            ],
            'codigo_emissor' => [
                'required',
                'string',
                'size:10',
            ],
            'equipe_id' => [
                'nullable',
                'integer',
                Rule::exists(Equipe::class, 'id'),
            ],
            'fonte_orcamentaria_id' => [
                'nullable',
                'integer',
                Rule::exists(FonteOrcamentaria::class, 'id'),
            ],
            'emenda_parlamentar' => [
                'required',
                'boolean'
            ],
            'laudo_geral.cid_principal_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'laudo_geral.cid_secundario_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'laudo_geral.data_identificacao_patologica' => [
                'nullable',
                'date_format:d/m/Y',
            ],
            'procedimentos_secundarios' => [
                'present',
                'array',
            ],
            'procedimentos_secundarios.*.procedimento_id' => [
                'required',
                'integer',
                Rule::exists(Procedimento::class, 'id'),
            ],
            'procedimentos_secundarios.*.ocupacao_id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'procedimentos_secundarios.*.quantidade' => [
                'required',
                'integer',
                'min:1',
            ],
            'procedimentos_secundarios.*.cnpj_cessao_credito' => [
                'nullable',
                'digits:14',
                new Cnpj,
            ],
            'procedimentos_secundarios.*.numero_nota_fiscal_cessao' => [
                'nullable',
                'string',
                'max:6',
            ],
            'procedimentos_secundarios.*.cid_principal_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'procedimentos_secundarios.*.cid_secundario_id' => [
                'nullable',
                'integer',
                Rule::exists(Cid::class, 'id'),
            ],
            'procedimentos_secundarios.*.servico_id' => [
                'nullable',
                'integer',
                Rule::exists(Servico::class, 'id'),
            ],
            'procedimentos_secundarios.*.classificacao_id' => [
                'nullable',
                'integer',
                Rule::exists(Classificacao::class, 'id'),
            ],
            'procedimentos_secundarios.*.unidade_prestadora_terceiro_cnes' => [
                'nullable',
                'string',
                'between:7,7',
            ],
        ]);
    }

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

        $params['data_processamento'] = Carbon::createFromFormat('d/m/Y', $params['data_processamento']);
        $params['data_inicial_validade'] = Carbon::createFromFormat('d/m/Y', $params['data_inicial_validade']);
        $params['data_final_validade'] = Carbon::createFromFormat('d/m/Y', $params['data_final_validade']);

        $params['data_ocorrencia'] = is_null($params['data_ocorrencia'])
            ? null : Carbon::createFromFormat('d/m/Y', $params['data_ocorrencia']);

        $params['data_solicitacao'] = Carbon::createFromFormat('d/m/Y', $params['data_solicitacao']);
        $params['data_autorizacao'] = Carbon::createFromFormat('d/m/Y', $params['data_autorizacao']);

        $params['laudo_geral']['data_identificacao_patologica'] = is_null($params['laudo_geral']['data_identificacao_patologica'])
            ? null : Carbon::createFromFormat('d/m/Y', $params['laudo_geral']['data_identificacao_patologica']);

        return $params;
    }

    private static function procedimentoExigeDadosComplementares($procedimentoId)
    {
        return Procedimento::findOrFail($procedimentoId)
            ->detalhes()
            ->where('codigo', Detalhe::EXIGE_REGISTRO_NA_APAC_DE_DADOS_COMPLEMENTARES)
            ->exists();
    }

    public static function destroyAutomaticos($unidadeExecutanteId, $competenciaId)
    {
        DB::transaction(function () use ($unidadeExecutanteId, $competenciaId) {

            DB::table('apac_solicitacao_autorizacao AS solicitacao_autorizacao')
                ->where('solicitacao_autorizacao.unidade_executante_id', $unidadeExecutanteId)
                ->where('solicitacao_autorizacao.competencia_id', $competenciaId)
                ->where('solicitacao_autorizacao.is_automatico', true)
                ->whereNull('solicitacao_autorizacao.exportacao_id')
                ->select(
                    'solicitacao_autorizacao.id'
                )
                ->get()
                ->each(function ($solicitacaoAutorizacao) {

                    AmbulatorioAtendimentoProcedimento::where('apac_solicitacao_autorizacao_id', $solicitacaoAutorizacao->id)
                        ->update(['apac_solicitacao_autorizacao_id' => null]);

                    AcompanhamentoOci::where('apac_solicitacao_autorizacao_id', $solicitacaoAutorizacao->id)
                        ->update(['apac_solicitacao_autorizacao_id' => null]);

                    DB::table('apac_solicitacao_autorizacao_procedimento_secundario')
                        ->where('solicitacao_autorizacao_id', $solicitacaoAutorizacao->id)
                        ->select('id')
                        ->get()
                        ->each(function ($procedimentoSecundario) {

                            AgendamentoExame::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                                ->update(['apac_procedimento_secundario_id' => null]);

                            Faturamento::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                                ->update(['apac_procedimento_secundario_id' => null]);

                            AmbulatorioAtendimentoProcedimento::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                                ->update(['apac_procedimento_secundario_id' => null]);

                            AcompanhamentoOciProcedimentoRealizado::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                                ->update(['apac_procedimento_secundario_id' => null]);
                        });

                    SolicitacaoAutorizacao::destroy($solicitacaoAutorizacao->id);
                });
        });
    }

    public static function destroy($id)
    {
        $solicitacaoAutorizacao = SolicitacaoAutorizacao::findOrFail($id);

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

            AmbulatorioAtendimentoProcedimento::where('apac_solicitacao_autorizacao_id', $solicitacaoAutorizacao->id)
                ->update(['apac_solicitacao_autorizacao_id' => null]);

            AcompanhamentoOci::where('apac_solicitacao_autorizacao_id', $solicitacaoAutorizacao->id)
                ->update(['apac_solicitacao_autorizacao_id' => null]);

            $solicitacaoAutorizacao->procedimentosSecundarios->each(function ($procedimentoSecundario) {

                AgendamentoExame::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                    ->update(['apac_procedimento_secundario_id' => null]);

                Faturamento::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                    ->update(['apac_procedimento_secundario_id' => null]);

                AmbulatorioAtendimentoProcedimento::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                    ->update(['apac_procedimento_secundario_id' => null]);

                AcompanhamentoOciProcedimentoRealizado::where('apac_procedimento_secundario_id', $procedimentoSecundario->id)
                    ->update(['apac_procedimento_secundario_id' => null]);
            });

            $solicitacaoAutorizacao->delete();
        });
    }
}