<?php

namespace App\Services\Regulacao;

use App\Enums\Ambulatorio\AcompanhamentoOciMotivoEncerramento as AmbulatorioAcompanhamentoOciMotivoEncerramento;
use App\Enums\Ambulatorio\AcompanhamentoOciStatus;
use App\Enums\Ambulatorio\AtendimentoSoapSolicitacaoExameItemStatus as AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus;
use App\Enums\Apac\MotivoSaidaPermanencia as ApacMotivoSaidaPermanencia;
use App\Enums\Cadastro\EtapaClinica;
use App\Enums\ExameLaboratorial\StatusAgendamento;
use App\Enums\Parametrizacao\Exame\Tipo;
use App\Enums\Regulacao\StatusTipo;
use App\Enums\Sigtap\Complexidade;
use App\Enums\Sigtap\Procedimento;
use App\Models\Ambulatorio\AcompanhamentoOci;
use App\Models\Ambulatorio\AcompanhamentoOciMotivoEncerramento;
use App\Models\Ambulatorio\AcompanhamentoOciProcedimentoRealizado;
use App\Models\Ambulatorio\AtendimentoSoapSolicitacaoExameItem;
use App\Models\Ambulatorio\AtendimentoSoapSolicitacaoExameItemStatus;
use App\Models\Apac\MotivoSaidaPermanencia;
use App\Models\Cadastro\SujeitoAtencao\Obito;
use App\Services\Ambulatorio\HistoricoAtendimentoService;
use App\Services\Cadastro\ObitoService;
use App\Services\Service;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;

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

        $params = self::getParams();

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

                $periodoOrigemData = self::getPeriodoOrigensData($params);

                $data->form['periodo_origens'] = $periodoOrigemData['form'];
                $data->model['periodo_origem'] = $periodoOrigemData['model'];

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

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

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

                $unidadeExecutoraData = self::getUnidadesExecutorasData($params);

                $data->form['unidades_executoras'] = $unidadeExecutoraData['form'];
                $data->model['unidade_executora_id'] = $unidadeExecutoraData['model'];

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

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

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

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

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

                $cidData = self::getCidsData($params);

                $data->form['cids'] = $cidData['form'];
                $data->model['cids'] = $cidData['model'];

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

                $situacaoProtocoloData = self::getSituacoesProtocolosData($params);

                $data->form['situacoes_protocolos'] = $situacaoProtocoloData['form'];
                $data->model['situacao_protocolo'] = $situacaoProtocoloData['model'];

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

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

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

                $etapaClinicaAtualData = self::getEtapasClinicasAtuaisData($params);

                $data->form['etapas_clinicas_atuais'] = $etapaClinicaAtualData['form'];
                $data->model['etapa_clinica_atual_id'] = $etapaClinicaAtualData['model'];

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

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

        if ($load) {

            $data->additionals = [
                'data_atual' => Carbon::today()->format('d/m/Y'),
            ];
        }

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

            if ($load) {

                if (!$firstLoad && collect(['periodo', 'linha_cuidado'])->contains($field)) {

                    continue;
                }

                $set();
            }
            else if ($field === request()->load_from) {

                $load = true;
            }
        }

        foreach ($data as $property => $itens) {

            if (empty($itens)) {

                unset($data->{$property});
            }
        }

        return $data;
    }

    private static function getParams()
    {
        $params = (object) [
            'periodo_origem' => request()->get('periodo_origem'),
            'periodo' => request()->get('periodo', ['start' => null, 'end' => null]),
            'unidade_executora_id' => request()->get('unidade_executora_id'),
            'usuario_responsavel_id' => request()->get('usuario_responsavel_id'),
            'paciente_id' => request()->get('paciente_id'),
            'cids' => request()->get('cids', []),
            'situacao_protocolo' => request()->get('situacao_protocolo'),
            'linha_cuidado' => request()->get('linha_cuidado'),
            'etapa_clinica_atual_id' => request()->get('etapa_clinica_atual_id'),
        ];

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

        $params->is_periodo_preenchido = !is_null($params->periodo['start']) && !is_null($params->periodo['end']);
        $params->periodo_origem_campo = $params->periodo_origem === 'inicio' ? 'iniciado_em' : 'finalizado_em';

        return $params;
    }

    private static function getPeriodoOrigensData()
    {
        $origens = collect([
            (object) ['value' => 'inicio', 'text' => 'Início'],
            (object) ['value' => 'finalizacao', 'text' => 'Encerramento'],
        ]);

        return ['form' => $origens, 'model' => 'inicio'];
    }

    private static function getUnidadesExecutorasData($params)
    {
        $unidadesExecutoras = DB::table('cadastro_unidade AS unidade')
            ->whereNull('unidade.deleted_at')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_infraestrutura AS infraestrutura')
                ->join('cadastro_lotacao AS lotacao', 'lotacao.infraestrutura_id', 'infraestrutura.id')
                ->join(
                    'ambulatorio_acompanhamento_oci AS acompanhamento_oci',
                    'acompanhamento_oci.iniciado_lotacao_id',
                    'lotacao.id'
                )
                ->whereColumn('infraestrutura.unidade_id', 'unidade.id')
                ->when($params->periodo['start'], fn ($q, $date) => $q
                    ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '>=', $date)
                )
                ->when($params->periodo['end'], fn ($q, $date) => $q
                    ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '<=', $date)
                )
            )
            ->select(
                'unidade.id',
                'unidade.nome_fantasia'
            )
            ->orderBy('unidade.nome_fantasia')
            ->get();

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

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

        return DB::table('cadastro_usuario AS usuario')
            ->join('cadastro_cidadao AS cidadao', 'cidadao.id', 'usuario.cidadao_id')
            ->whereNull('usuario.deleted_at')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('cadastro_lotacao AS lotacao')
                ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                ->join(
                    'ambulatorio_acompanhamento_oci AS acompanhamento_oci',
                    'acompanhamento_oci.iniciado_lotacao_id',
                    'lotacao.id'
                )
                ->whereColumn('usuario.id', 'lotacao.usuario_id')
                ->when($params->periodo['start'], fn ($q, $date) => $q
                    ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '>=', $date)
                )
                ->when($params->periodo['end'], fn ($q, $date) => $q
                    ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '<=', $date)
                )
                ->when($params->unidade_executora_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
            )
            ->select(
                'usuario.id',
                'cidadao.nome'
            );
    }

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

        return DB::table('cadastro_paciente AS paciente')
            ->join('cadastro_cidadao AS cidadao', 'cidadao.id', 'paciente.cidadao_id')
            ->whereNull('paciente.deleted_at')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('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')
                ->whereColumn('acompanhamento_oci.paciente_id', 'paciente.id')
                ->when($params->periodo['start'], fn ($q, $date) => $q
                    ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '>=', $date)
                )
                ->when($params->periodo['end'], fn ($q, $date) => $q
                    ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '<=', $date)
                )
                ->when($params->unidade_executora_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                ->when($params->usuario_responsavel_id, fn ($q, $id) => $q->where('lotacao.usuario_id', $id))
            )
            ->select(
                'paciente.id',
                'cidadao.nome',
            );
    }

    private static function getCidsData($params)
    {
        $cids = collect();

        if ($params->is_periodo_preenchido || !is_null($params->unidade_executora_id)) {

            $cids = DB::table('sigtap.cid AS cid')
                ->where(fn ($q) => $q
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('ambulatorio_atendimento_soap_problema_condicao AS problema_condicao')
                        ->join(
                            'ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS oci_etapa_clinica_concluida',
                            'oci_etapa_clinica_concluida.soap_id',
                            'problema_condicao.soap_id'
                        )
                        ->join(
                            'ambulatorio_acompanhamento_oci AS acompanhamento_oci',
                            'acompanhamento_oci.id',
                            'oci_etapa_clinica_concluida.acompanhamento_oci_id'
                        )
                        ->join('cadastro_oci AS oci', 'oci.id', 'acompanhamento_oci.oci_id')
                        ->join('sigtap.procedimento AS procedimento', fn ($j) => $j
                            ->on('procedimento.codigo', 'oci.procedimento_codigo')
                            ->where('procedimento.competencia_id', DB::table('sigtap.competencia')->max('id'))
                        )
                        ->join('cadastro_lotacao AS lotacao', 'lotacao.id', 'acompanhamento_oci.iniciado_lotacao_id')
                        ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                        ->whereColumn('problema_condicao.cid_id', 'cid.id')
                        ->whereExists(fn ($q) => $q
                            ->selectRaw(1)
                            ->from('sigtap.procedimento_cid AS procedimento_cid')
                            ->whereColumn('procedimento_cid.cid_id', 'problema_condicao.cid_id')
                            ->whereColumn('procedimento_cid.procedimento_id', 'procedimento.id')
                        )
                        ->when($params->periodo['start'], fn ($q, $date) => $q
                            ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '>=', $date)
                        )
                        ->when($params->periodo['end'], fn ($q, $date) => $q
                            ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '<=', $date)
                        )
                        ->when($params->unidade_executora_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                        ->when($params->usuario_responsavel_id, fn ($q, $id) => $q->where('lotacao.usuario_id', $id))
                        ->when($params->paciente_id, fn ($q, $id) => $q->where('acompanhamento_oci.paciente_id', $id))
                    )
                    ->orWhereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao AS solicitacao')
                        ->join(
                            'ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS oci_etapa_clinica_concluida',
                            'oci_etapa_clinica_concluida.regulacao_solicitacao_id',
                            'solicitacao.id'
                        )
                        ->join(
                            'ambulatorio_acompanhamento_oci AS acompanhamento_oci',
                            'acompanhamento_oci.id',
                            'oci_etapa_clinica_concluida.acompanhamento_oci_id'
                        )
                        ->join('cadastro_lotacao AS lotacao', 'lotacao.id', 'acompanhamento_oci.iniciado_lotacao_id')
                        ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                        ->whereColumn('solicitacao.cid_id', 'cid.id')
                        ->when($params->periodo['start'], fn ($q, $date) => $q
                            ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '>=', $date)
                        )
                        ->when($params->periodo['end'], fn ($q, $date) => $q
                            ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '<=', $date)
                        )
                        ->when($params->unidade_executora_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                        ->when($params->usuario_responsavel_id, fn ($q, $id) => $q->where('lotacao.usuario_id', $id))
                        ->when($params->paciente_id, fn ($q, $id) => $q->where('acompanhamento_oci.paciente_id', $id))
                    )
                )
                ->select(
                    'cid.id',
                    'cid.codigo',
                    'cid.nome'
                )
                ->orderByRaw("CONCAT(cid.codigo, ' - ', cid.nome)")
                ->get()
                ->map(fn ($cid) => (object) [
                    'id' => $cid->id,
                    'descricao' => MaskUtil::getCidMasked($cid->codigo) . " {$cid->nome}",
                ]);
        }

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

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

    private static function getSituacoesProtocolosData($params)
    {
        $situacoesProtocolo = collect();

        if ($params->is_periodo_preenchido || !is_null($params->unidade_executora_id)) {

            $getBaseQuery = function () use ($params) {

                return DB::table('ambulatorio_acompanhamento_oci AS acompanhamento_oci')
                    ->join('cadastro_oci AS oci', 'oci.id', 'acompanhamento_oci.oci_id')
                    ->join('cadastro_lotacao AS lotacao', 'lotacao.id', 'acompanhamento_oci.iniciado_lotacao_id')
                    ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                    ->when($params->periodo['start'], fn ($q, $date) => $q
                        ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '>=', $date)
                    )
                    ->when($params->periodo['end'], fn ($q, $date) => $q
                        ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '<=', $date)
                    )
                    ->when($params->unidade_executora_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                    ->when($params->usuario_responsavel_id, fn ($q, $id) => $q->where('lotacao.usuario_id', $id))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('acompanhamento_oci.paciente_id', $id))
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS oci_etapa_clinica_concluida')
                        ->whereColumn('oci_etapa_clinica_concluida.acompanhamento_oci_id', 'acompanhamento_oci.id')
                        ->where(fn ($q) => $q
                            ->whereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('ambulatorio_atendimento_soap_problema_condicao AS problema_condicao')
                                ->whereColumn('problema_condicao.soap_id', 'oci_etapa_clinica_concluida.soap_id')
                                ->whereIn('problema_condicao.cid_id', $params->cids)
                            )
                            ->orWhereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('regulacao_solicitacao AS solicitacao')
                                ->whereColumn('solicitacao.id', 'oci_etapa_clinica_concluida.regulacao_solicitacao_id')
                                ->whereIn('solicitacao.cid_id', $params->cids)
                            )
                        )
                );
            };

            $hasProtocoloAtivo = $getBaseQuery()
                ->whereNull('acompanhamento_oci.finalizado_em')
                ->whereRaw("CURRENT_DATE <= LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))")
                ->exists();

            $hasProtocoloEncerrado = $getBaseQuery()
                ->whereNotNull('acompanhamento_oci.finalizado_em')
                ->exists();

            $hasProtocoloExpirado = $getBaseQuery()
                ->whereNull('acompanhamento_oci.finalizado_em')
                ->whereRaw("CURRENT_DATE > LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))")
                ->exists();

            if ($hasProtocoloAtivo) {

                $situacoesProtocolo->push((object) ['value' => 'ativo', 'text' => 'Ativo']);
            }

            if ($hasProtocoloEncerrado) {

                $situacoesProtocolo->push((object) ['value' => 'encerrado', 'text' => 'Encerrado']);
            }

            if ($hasProtocoloExpirado) {

                $situacoesProtocolo->push((object) ['value' => 'expirado', 'text' => 'Expirado']);
            }
        }

        return ['form' => $situacoesProtocolo->sortBy('text')->values(), 'model' => null];
    }

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

        if ($params->is_periodo_preenchido || !is_null($params->unidade_executora_id)) {

            $etapasClinicas = DB::table('cadastro_etapa_clinica AS etapa_clinica')
                ->whereExists(fn ($q) => $q
                    ->selectRaw(1)
                    ->from('ambulatorio_acompanhamento_oci AS acompanhamento_oci')
                    ->join('cadastro_oci AS oci', 'oci.id', 'acompanhamento_oci.oci_id')
                    ->join('cadastro_lotacao AS lotacao', 'lotacao.id', 'acompanhamento_oci.iniciado_lotacao_id')
                    ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
                    ->whereColumn('acompanhamento_oci.etapa_clinica_atual_id', 'etapa_clinica.id')
                    ->when($params->periodo['start'], fn ($q, $date) => $q
                        ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '>=', $date)
                    )
                    ->when($params->periodo['end'], fn ($q, $date) => $q
                        ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '<=', $date)
                    )
                    ->when($params->unidade_executora_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
                    ->when($params->usuario_responsavel_id, fn ($q, $id) => $q->where('lotacao.usuario_id', $id))
                    ->when($params->paciente_id, fn ($q, $id) => $q->where('acompanhamento_oci.paciente_id', $id))
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS oci_etapa_clinica_concluida')
                        ->whereColumn('oci_etapa_clinica_concluida.acompanhamento_oci_id', 'acompanhamento_oci.id')
                        ->where(fn ($q) => $q
                            ->whereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('ambulatorio_atendimento_soap_problema_condicao AS problema_condicao')
                                ->whereColumn('problema_condicao.soap_id', 'oci_etapa_clinica_concluida.soap_id')
                                ->whereIn('problema_condicao.cid_id', $params->cids)
                            )
                            ->orWhereExists(fn ($q) => $q
                                ->selectRaw(1)
                                ->from('regulacao_solicitacao AS solicitacao')
                                ->whereColumn('solicitacao.id', 'oci_etapa_clinica_concluida.regulacao_solicitacao_id')
                                ->whereIn('solicitacao.cid_id', $params->cids)
                            )
                        )
                    )
                    ->when($params->situacao_protocolo === 'ativo', fn ($q) => $q
                        ->whereNull('acompanhamento_oci.finalizado_em')
                        ->whereRaw("CURRENT_DATE <= LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))")
                    )
                    ->when($params->situacao_protocolo === 'encerrado', fn ($q) => $q
                        ->whereNotNull('acompanhamento_oci.finalizado_em')
                    )
                    ->when($params->situacao_protocolo === 'expirado', fn ($q) => $q
                        ->whereNull('acompanhamento_oci.finalizado_em')
                        ->whereRaw("CURRENT_DATE > LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))")
                    )
                    ->when($params->linha_cuidado, fn ($q, $linhaCuidado) => $q
                        ->where('oci.linha_cuidado', 'like', "{$linhaCuidado}%")
                    )
                )
                ->select(
                    'etapa_clinica.id',
                    'etapa_clinica.nome'
                )
                ->get();
        }

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

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

        return DB::table('ambulatorio_acompanhamento_oci AS acompanhamento_oci')
            ->join('ambulatorio_acompanhamento_oci_status AS status', 'status.id', 'acompanhamento_oci.status_id')
            ->join('cadastro_oci AS oci', 'oci.id', 'acompanhamento_oci.oci_id')
            ->join('sigtap.procedimento AS procedimento', fn ($j) => $j
                ->on('procedimento.codigo', 'oci.procedimento_codigo')
                ->where('procedimento.competencia_id', DB::table('sigtap.competencia')->max('id'))
            )
            ->join(
                'cadastro_etapa_clinica AS etapa_clinica_atual',
                'etapa_clinica_atual.id',
                'acompanhamento_oci.etapa_clinica_atual_id'
            )
            ->join('cadastro_paciente AS paciente', 'paciente.id', 'acompanhamento_oci.paciente_id')
            ->join('cadastro_cidadao AS paciente_cidadao', 'paciente_cidadao.id', 'paciente.cidadao_id')
            ->join('cadastro_lotacao AS lotacao', 'lotacao.id', 'acompanhamento_oci.iniciado_lotacao_id')
            ->join('cadastro_usuario AS usuario', 'usuario.id', 'lotacao.usuario_id')
            ->join('cadastro_cidadao AS usuario_cidadao', 'usuario_cidadao.id', 'usuario.cidadao_id')
            ->join('cadastro_infraestrutura AS infraestrutura', 'infraestrutura.id', 'lotacao.infraestrutura_id')
            ->join('cadastro_unidade AS unidade', 'unidade.id', 'infraestrutura.unidade_id')
            ->leftJoin('cadastro_sexo AS sexo', 'sexo.id', 'paciente_cidadao.sexo_id')
            ->when($params->periodo['start'], fn ($q, $date) => $q
                ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '>=', $date)
            )
            ->when($params->periodo['end'], fn ($q, $date) => $q
                ->whereDate("acompanhamento_oci.{$params->periodo_origem_campo}", '<=', $date)
            )
            ->when($params->unidade_executora_id, fn ($q, $id) => $q->where('infraestrutura.unidade_id', $id))
            ->when($params->usuario_responsavel_id, fn ($q, $id) => $q->where('lotacao.usuario_id', $id))
            ->when($params->paciente_id, fn ($q, $id) => $q->where('acompanhamento_oci.paciente_id', $id))
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS oci_etapa_clinica_concluida')
                ->whereColumn('oci_etapa_clinica_concluida.acompanhamento_oci_id', 'acompanhamento_oci.id')
                ->where(fn ($q) => $q
                    ->whereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('ambulatorio_atendimento_soap_problema_condicao AS problema_condicao')
                        ->whereColumn('problema_condicao.soap_id', 'oci_etapa_clinica_concluida.soap_id')
                        ->whereIn('problema_condicao.cid_id', $params->cids)
                    )
                    ->orWhereExists(fn ($q) => $q
                        ->selectRaw(1)
                        ->from('regulacao_solicitacao AS solicitacao')
                        ->whereColumn('solicitacao.id', 'oci_etapa_clinica_concluida.regulacao_solicitacao_id')
                        ->whereIn('solicitacao.cid_id', $params->cids)
                    )
                )
            )
            ->when($params->situacao_protocolo === 'ativo', fn ($q) => $q
                ->whereNull('acompanhamento_oci.finalizado_em')
                ->whereRaw("CURRENT_DATE <= LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))")
            )
            ->when($params->situacao_protocolo === 'encerrado', fn ($q) => $q
                ->whereNotNull('acompanhamento_oci.finalizado_em')
            )
            ->when($params->situacao_protocolo === 'expirado', fn ($q) => $q
                ->whereNull('acompanhamento_oci.finalizado_em')
                ->whereRaw("CURRENT_DATE > LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))")
            )
            ->when($params->linha_cuidado, fn ($q, $linhaCuidado) => $q
                ->where('oci.linha_cuidado', 'like', "{$linhaCuidado}%")
            )
            ->when($params->etapa_clinica_atual_id, fn ($q, $id) => $q->where('acompanhamento_oci.etapa_clinica_atual_id', $id))
            ->select(
                'acompanhamento_oci.id',
                'status.nome AS status_nome',
                DB::raw("DATE_FORMAT(CAST(acompanhamento_oci.iniciado_em AS DATE), '%d/%m/%Y') AS data_inicio"),
                DB::raw("DATE_FORMAT(CAST(acompanhamento_oci.finalizado_em AS DATE), '%d/%m/%Y') AS data_finalizacao"),
                DB::raw("LPAD(paciente.prontuario, 7, '0') as paciente_prontuario"),
                'paciente_cidadao.nome AS paciente_nome',
                'paciente_cidadao.data_nascimento AS paciente_data_nascimento',
                'sexo.descricao AS paciente_sexo_descricao',
                'oci.linha_cuidado',
                'usuario_cidadao.nome AS usuario_responsavel_nome',
                'unidade.nome_fantasia AS unidade_executora_nome_fantasia',
                'etapa_clinica_atual.nome AS etapa_clinica_atual_nome',
                DB::raw("DATE_FORMAT(LAST_DAY(DATE_ADD(
                    CAST(acompanhamento_oci.iniciado_em AS DATE
                ), INTERVAL 1 MONTH)), '%d/%m/%Y') AS validade"),
                DB::raw("IF(acompanhamento_oci.finalizado_em IS NULL, TIMESTAMPDIFF(DAY,
                    CURRENT_DATE,
                    LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))
                ), NULL) AS prazo_restante"),
                DB::raw("IF(acompanhamento_oci.finalizado_em IS NULL, 0, 1) AS is_concluido"),
                DB::raw("IF(CURRENT_DATE > LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH)), 1, 0) AS is_vencido"),
                DB::raw("TIMESTAMPDIFF(
                    DAY,
                    acompanhamento_oci.iniciado_em,
                    COALESCE(acompanhamento_oci.finalizado_em, CURRENT_DATE)
                ) AS tempo_dias"),
                DB::raw("IF(acompanhamento_oci.finalizado_em IS NOT NULL,
                    NULL,
                    IF(CURRENT_DATE > LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH))
                        AND TIMESTAMPDIFF(DAY, LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH)), CURRENT_DATE) > 1,
                        TIMESTAMPDIFF(DAY, LAST_DAY(DATE_ADD(CAST(acompanhamento_oci.iniciado_em AS DATE), INTERVAL 1 MONTH)), CURRENT_DATE),
                        NULL
                    )
                ) AS dias_atrasado"),
                DB::raw("(
                    SELECT      GROUP_CONCAT(CONCAT(
                                    REGEXP_REPLACE(cid.codigo, '([[:alnum:]]{3})([[:alnum:]]{1})', '\\\\1.\\\\2'),
                                    ' - ',
                                    cid.nome
                                ) SEPARATOR '#')
                    FROM        sigtap.cid AS cid
                    WHERE       (
                        EXISTS (
                            SELECT      1
                            FROM        ambulatorio_atendimento_soap_problema_condicao AS problema_condicao
                            JOIN        ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS oci_etapa_clinica_concluida
                            ON          oci_etapa_clinica_concluida.soap_id = problema_condicao.soap_id
                            WHERE       problema_condicao.cid_id = cid.id
                            AND         oci_etapa_clinica_concluida.acompanhamento_oci_id = acompanhamento_oci.id
                            AND         EXISTS (
                                SELECT      1
                                FROM        sigtap.procedimento_cid AS procedimento_cid
                                WHERE       procedimento_cid.cid_id = problema_condicao.cid_id
                                AND         procedimento_cid.procedimento_id = procedimento.id
                            )
                        )
                        OR EXISTS (
                            SELECT      1
                            FROM        regulacao_solicitacao AS solicitacao
                            JOIN        ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS oci_etapa_clinica_concluida
                            ON          oci_etapa_clinica_concluida.regulacao_solicitacao_id = solicitacao.id
                            WHERE       solicitacao.cid_id = cid.id
                            AND         oci_etapa_clinica_concluida.acompanhamento_oci_id = acompanhamento_oci.id
                        )
                    )
                    ORDER BY        CONCAT(cid.codigo, ' - ', cid.nome)
                ) AS cids"),
                'paciente.updated_at AS paciente_updated_at',
                'paciente_cidadao.updated_at AS paciente_cidadao_updated_at'
            )
            ->addSelect([
                'is_paciente_em_obito' => fn ($q) => $q
                    ->selectRaw(1)
                    ->from('cadastro_obito AS obito')
                    ->whereColumn('obito.cidadao_id', 'paciente_cidadao.id')
                    ->whereNull('obito.deleted_at')
                    ->limit(1),
            ]);
    }

    public static function getAtendimentos($acompanhamentoOciId)
    {
        $acompanhamentoOci = AcompanhamentoOci::findOrFail($acompanhamentoOciId);

        $soaps = DB::table('ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS etapa_clinica_concluida')
            ->whereNotNull('etapa_clinica_concluida.soap_id')
            ->where('etapa_clinica_concluida.acompanhamento_oci_id', $acompanhamentoOci->id)
            ->select(
                'etapa_clinica_concluida.soap_id',
            )
            ->get()
            ->pluck('soap_id')
            ->concat(DB::table('regulacao_solicitacao AS solicitacao')
                ->join(
                    'ambulatorio_acompanhamento_oci_etapa_clinica_concluida AS etapa_clinica_concluida',
                    'etapa_clinica_concluida.regulacao_solicitacao_id',
                    'solicitacao.id'
                )
                ->whereNotNull('solicitacao.soap_id')
                ->where('etapa_clinica_concluida.acompanhamento_oci_id', $acompanhamentoOci->id)
                ->select(
                    'solicitacao.soap_id',
                )
                ->get()
                ->pluck('soap_id')
            );

        $historico = HistoricoAtendimentoService::show($acompanhamentoOci->paciente_id);

        return [
            'form' => [
                'paciente' => $historico['form']['paciente'],
                'historico' => $historico['form']['historico']
                    ->where('origem', 'ambulatorio')
                    ->where('tipo', 'atendimento')
                    ->whereIn('id', $soaps)
                    ->values(),
            ],
        ];
    }

    public static function getSolicitacoes($acompanhamentoOciId)
    {
        $acompanhamentoOci = AcompanhamentoOci::findOrFail($acompanhamentoOciId);

        $procedimentosOci = $acompanhamentoOci->oci->procedimentosPrimarios->pluck('procedimento_codigo')
            ->concat($acompanhamentoOci->oci->procedimentosSecundarios->pluck('procedimento_codigo'));

        $itens = 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('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')
            ->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_usuario as usuario', 'usuario.id', 'lotacao.usuario_id')
            ->join('cadastro_cidadao as usuario_cidadao', 'usuario_cidadao.id', 'usuario.cidadao_id')
            ->join('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'lotacao.ocupacao_id')
            ->join('sigtap.procedimento as procedimento', fn ($j) => $j
                ->on('procedimento.codigo', 'exame.codigo')
                ->where('procedimento.competencia_id', DB::table('sigtap.competencia')->max('id'))
            )
            ->leftJoin('sigtap.cid AS cid', 'cid.id', 'solicitacao_exame.cid_id')
            ->leftJoin('geral_ciap AS ciap', 'ciap.id', 'solicitacao_exame.ciap_id')
            ->leftJoin('cadastro_unidade as unidade_executora', 'unidade_executora.id', 'solicitacao_exame_item.unidade_executora_id')
            ->leftJoin('sigtap.ocupacao as ocupacao_executora', 'ocupacao_executora.id', 'solicitacao_exame_item.ocupacao_executora_id')
            ->where('soap.acompanhamento_oci_id', $acompanhamentoOci->id)
            ->whereIn('exame.codigo', $procedimentosOci)
            ->select(
                'solicitacao_exame_item.id',
                'soap.atendimento_id',
                DB::raw("CAST(solicitacao_exame.created_at AS DATE) as data_solicitacao"),
                'usuario_cidadao.nome AS usuario_solicitante_nome',
                DB::raw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) AS usuario_solicitante_ocupacao_descricao"),
                'cid.id AS cid_id',
                'cid.codigo AS cid_codigo',
                'cid.nome AS cid_nome',
                DB::raw("CONCAT(ciap.codigo, ' - ', ciap.descricao) AS ciap_descricao"),
                'solicitacao_exame.justificativa',
                'solicitacao_exame.observacao',
                'procedimento.id as procedimento_id',
                'procedimento.complexidade AS procedimento_complexidade',
                'exame.id as exame_id',
                'exame.codigo AS exame_codigo',
                'exame.nome AS exame_nome',
                'exame.tipo_id AS exame_tipo_id',
                'solicitacao_exame_item.status_id as externo_nao_regulado_status_id',
                'solicitacao_exame_item.data_agendada as externo_nao_regulado_data_agendada',
                'unidade_executora.id as externo_nao_regulado_unidade_executora_id',
                'ocupacao_executora.id as externo_nao_regulado_ocupacao_executora_id',
                'ocupacao_executora.codigo as externo_nao_regulado_ocupacao_executora_codigo',
                'ocupacao_executora.nome as externo_nao_regulado_ocupacao_executora_nome',
                'solicitacao_exame_item.usuario_executor_nome as externo_nao_regulado_usuario_executor_nome'
            )
            ->get();

        $itens->each(function ($item) {

            $item->is_exame_laboratorial = $item->exame_tipo_id === Tipo::LABORATORIAL;
            $item->is_alta_complexidade = $item->procedimento_complexidade === Complexidade::ALTA_COMPLEXIDADE;

            $item->cid_descricao = is_null($item->cid_id)
                ? null
                : (MaskUtil::getCidMasked($item->cid_codigo) . " - {$item->cid_nome}");

            $item->exame_descricao = is_null($item->exame_codigo)
                ? $item->exame_nome
                : (MaskUtil::getProcedimentoMasked($item->exame_codigo) . " - {$item->exame_nome}");

            $item->is_externo_nao_regulado = false;
            $item->status = null;
            $item->data_agendada = null;
            $item->unidade_executora = null;
            $item->ocupacao_executora = null;
            $item->usuario_executor = null;

            if (DB::table('regulacao_solicitacao_item')->where('soap_solicitacao_item_id', $item->id)->exists()) {

                self::setRegulacaoData($item);
            }
            else if (DB::table('exame_laboratorial_agendamento_exame')->where('soap_solicitacao_exame_item_id', $item->id)->exists()) {

                self::setExameLaboratorialData($item);
            }
            else if (DB::table('exame_imagem_agendamento_exame')->where('soap_solicitacao_exame_item_id', $item->id)->exists()) {

                self::setExameImagemData($item);
            }
            else {

                if (is_null($item->externo_nao_regulado_status_id)) {

                    $item->externo_nao_regulado_status_id = AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::SOLICITADO;
                }

                $item->is_externo_nao_regulado = true;
                $item->status = $item->externo_nao_regulado_status_id;
                $item->data_agendada = $item->externo_nao_regulado_data_agendada;
                $item->unidade_executora = $item->externo_nao_regulado_unidade_executora_id;

                $item->ocupacao_executora = isset($item->externo_nao_regulado_ocupacao_executora_id)
                    ? [
                        'id' => $item->externo_nao_regulado_ocupacao_executora_id,
                        'codigo' => $item->externo_nao_regulado_ocupacao_executora_codigo,
                        'nome' => $item->externo_nao_regulado_ocupacao_executora_nome,
                    ] : null;

                $item->usuario_executor = $item->externo_nao_regulado_usuario_executor_nome;

                if ($item->externo_nao_regulado_status_id === AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::SOLICITADO) {

                    $item->status_permitidos = [
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::SOLICITADO,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::AGENDADO,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REALIZADO,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::CANCELADO,
                    ];
                }
                else if ($item->externo_nao_regulado_status_id === AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::AGENDADO) {

                    $item->status_permitidos = [
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::AGENDADO,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REALIZADO,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::FALTA,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::CANCELADO,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REAGENDADO,
                    ];
                }
                else if ($item->externo_nao_regulado_status_id === AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REAGENDADO) {

                    $item->status_permitidos = [
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REALIZADO,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::FALTA,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::CANCELADO,
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REAGENDADO,
                    ];
                }
                else if ($item->externo_nao_regulado_status_id === AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::FALTA) {

                    $item->status_permitidos = [
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::FALTA,
                    ];
                }
                else if ($item->externo_nao_regulado_status_id === AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::CANCELADO) {

                    $item->status_permitidos = [
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::CANCELADO,
                    ];
                }
                else if ($item->externo_nao_regulado_status_id === AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REALIZADO) {

                    $item->status_permitidos = [
                        AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REALIZADO,
                    ];
                }
            }

            unset(
                $item->procedimento_complexidade,
                $item->exame_tipo_id,
                $item->cid_id,
                $item->cid_codigo,
                $item->cid_nome,
                $item->exame_id,
                $item->exame_nome,
                $item->externo_nao_regulado_status_id,
                $item->externo_nao_regulado_data_agendada,
                $item->externo_nao_regulado_unidade_executora_id,
                $item->externo_nao_regulado_ocupacao_executora_id,
                $item->externo_nao_regulado_ocupacao_executora_codigo,
                $item->externo_nao_regulado_ocupacao_executora_nome,
                $item->externo_nao_regulado_usuario_executor_nome,
            );
        });

        $procedimentosRealizados = DB::table('ambulatorio_acompanhamento_oci_procedimento_realizado AS procedimento_realizado')
            ->join('sigtap.procedimento AS procedimento', 'procedimento.id', 'procedimento_realizado.procedimento_id')
            ->leftJoin('sigtap.ocupacao AS ocupacao', 'ocupacao.id', 'procedimento_realizado.ocupacao_executora_id')
            ->where('procedimento_realizado.acompanhamento_oci_id', $acompanhamentoOci->id)
            ->select(
                'procedimento_realizado.id',
                'procedimento.id as procedimento_id',
                'procedimento.codigo as procedimento_codigo',
                'procedimento.nome as procedimento_nome',
                'procedimento_realizado.data_executada',
                'procedimento_realizado.unidade_executora_id',
                'ocupacao.id as ocupacao_id',
                'ocupacao.codigo as ocupacao_codigo',
                'ocupacao.nome as ocupacao_nome',
                'procedimento_realizado.usuario_executor_nome'
            )
            ->get()
            ->map(fn ($procedimentoRealizado) => [
                'id' => $procedimentoRealizado->id,
                'procedimento_id' => $procedimentoRealizado->procedimento_id,
                'procedimento_codigo' => $procedimentoRealizado->procedimento_codigo,
                'procedimento_descricao' => MaskUtil::getProcedimentoMasked($procedimentoRealizado->procedimento_codigo)
                    . " - {$procedimentoRealizado->procedimento_nome}",
                'data_executada' => $procedimentoRealizado->data_executada,
                'unidade_executora_id' => $procedimentoRealizado->unidade_executora_id,
                'ocupacao_executora' => is_null($procedimentoRealizado->ocupacao_id)
                    ? null
                    : [
                        'id' => $procedimentoRealizado->ocupacao_id,
                        'codigo' => $procedimentoRealizado->ocupacao_codigo,
                        'nome' => $procedimentoRealizado->ocupacao_nome,
                    ],
                'usuario_executor_nome' => $procedimentoRealizado->usuario_executor_nome,
            ]);

        $procedimentosOciCompetenciaAtual = DB::table('sigtap.procedimento as procedimento')
            ->where('procedimento.competencia_id', DB::table('sigtap.competencia')->max('id'))
            ->whereIn('procedimento.codigo', collect($procedimentosOci)
                ->filter(fn ($codigo) => !collect([
                    Procedimento::CONSULTA_MEDICA_EM_ATENCAO_ESPECIALIZADA,
                    Procedimento::TELECONSULTA_MEDICA_NA_ATENCAO_ESPECIALIZADA,
                ])
                ->contains($codigo))
                ->all()
            )
            ->select(
                'procedimento.id',
                'procedimento.codigo',
                'procedimento.nome'
            )
            ->orderByRaw("CONCAT(procedimento.codigo, ' - ', procedimento.nome)")
            ->get()
            ->map(fn ($procedimento) => [
                'id' => $procedimento->id,
                'codigo' => $procedimento->codigo,
                'descricao' => MaskUtil::getProcedimentoMasked($procedimento->codigo) . " - {$procedimento->nome}",
            ]);

        return [
            'additionals' => [
                'data_atual' => Carbon::now()->format('d/m/Y'),
            ],
            'form' => [
                'status' => AtendimentoSoapSolicitacaoExameItemStatus::orderBy('nome')->get(['id', 'nome']),
                'unidades_executoras' => $acompanhamentoOci->oci->unidadesExecutoras->map(fn ($unidadeExecutora) => [
                    'id' => $unidadeExecutora->unidade->id,
                    'nome_fantasia' => $unidadeExecutora->unidade->nome_fantasia,
                ])->sortBy('nome_fantasia')->values(),
                'procedimentos_oci' => $procedimentosOciCompetenciaAtual,
            ],
            'model' => [
                'solicitacoes_itens' => $itens,
                'procedimentos_realizados' => $procedimentosRealizados
            ]
        ];
    }

    public static function updateSolicitacoes($acompanhamentoOciId)
    {
        $acompanhamentoOci = AcompanhamentoOci::findOrFail($acompanhamentoOciId);

        self::validateUpdateSolicitacoes();

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

            foreach (request()->solicitacoes as $solicitacao) {

                AtendimentoSoapSolicitacaoExameItem::findOrFail($solicitacao['id'])->update([
                    'status_id' => $solicitacao['status_id'],
                    'data_agendada' => $solicitacao['data_agendada'] ? Carbon::createFromFormat('d/m/Y', $solicitacao['data_agendada']) : null,
                    'unidade_executora_id' => $solicitacao['unidade_executora_id'],
                    'ocupacao_executora_id' => $solicitacao['ocupacao_executora_id'],
                    'usuario_executor_nome' => $solicitacao['usuario_executor_nome'],
                ]);
            }

            foreach (request()->procedimentos_realizados as $prodimentoRealizado) {

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

                    $acompanhamentoOci->procedimentosRealizados()->create([
                        'procedimento_id' => $prodimentoRealizado['procedimento_id'],
                        'data_executada' => $prodimentoRealizado['data_executada']
                            ? Carbon::createFromFormat('d/m/Y', $prodimentoRealizado['data_executada']) : null,
                        'unidade_executora_id' => $prodimentoRealizado['unidade_executora_id'],
                        'ocupacao_executora_id' => $prodimentoRealizado['ocupacao_executora_id'],
                        'usuario_executor_nome' => $prodimentoRealizado['usuario_executor_nome'],
                    ]);
                }
                else {

                    AcompanhamentoOciProcedimentoRealizado::findOrFail($prodimentoRealizado['id'])->update([
                        'data_executada' => $prodimentoRealizado['data_executada']
                            ? Carbon::createFromFormat('d/m/Y', $prodimentoRealizado['data_executada']) : null,
                        'unidade_executora_id' => $prodimentoRealizado['unidade_executora_id'],
                        'ocupacao_executora_id' => $prodimentoRealizado['ocupacao_executora_id'],
                        'usuario_executor_nome' => $prodimentoRealizado['usuario_executor_nome'],
                    ]);
                }
            }
        });
    }

    private static function validateUpdateSolicitacoes()
    {
        request()->validate([
            'solicitacoes' => [
                'present',
                'array',
            ],
            'solicitacoes.*.id' => [
                'required',
                'integer',
            ],
            'solicitacoes.*.status_id' => [
                'required',
                'integer',
            ],
            'solicitacoes.*.data_agendada' => [
                'nullable',
                'date_format:d/m/Y',
            ],
            'solicitacoes.*.unidade_executora_id' => [
                'nullable',
                'integer',
            ],
            'solicitacoes.*.ocupacao_executora_id' => [
                'nullable',
                'integer',
            ],
            'solicitacoes.*.usuario_executor_nome' => [
                'nullable',
                'string',
                'max:100',
            ],
            'procedimentos_realizados' => [
                'present',
                'array',
            ],
            'procedimentos_realizados.*.id' => [
                'nullable',
                'integer',
            ],
            'procedimentos_realizados.*.procedimento_id' => [
                'required',
                'integer',
            ],
            'procedimentos_realizados.*.data_executada' => [
                'required',
                'date_format:d/m/Y',
            ],
            'procedimentos_realizados.*.unidade_executora_id' => [
                'required',
                'integer',
            ],
            'procedimentos_realizados.*.ocupacao_executora_id' => [
                'required',
                'integer',
            ],
            'procedimentos_realizados.*.usuario_executor_nome' => [
                'nullable',
                'string',
                'max:100',
            ],
        ]);
    }

    private static function setRegulacaoData($item)
    {
        $data = DB::table('regulacao_solicitacao_item as item')
            ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'item.solicitacao_id')
            ->join('regulacao_status as status', 'status.id', 'solicitacao.status_id')
            ->join('regulacao_status_tipo as status_tipo', 'status_tipo.id', 'status.tipo_id')
            ->leftJoin('regulacao_parametrizacao_prestador_externo as prestador_externo', 'prestador_externo.id', 'solicitacao.prestador_externo_id')
            ->leftJoin('transporte_paciente_destino as destino', 'destino.id', 'prestador_externo.destino_id')
            ->leftJoin('sigtap.ocupacao as ocupacao_executora', 'ocupacao_executora.id', 'solicitacao.ocupacao_executora_id')
            ->where('item.soap_solicitacao_item_id', $item->id)
            ->select(
                'item.solicitacao_id',
                'status_tipo.id as status_tipo_id',
                'status.nome as status_nome',
                'solicitacao.prestador_interno_id',
                'solicitacao.prestador_externo_id',
                'destino.descricao_destino as destino_descricao',
                'solicitacao.data_agendada',
                'solicitacao.usuario_executor_nome',
                'ocupacao_executora.codigo as ocupacao_executora_codigo'
            )
            ->first();

        $item->status = $data->status_nome;

        if (!is_null($data->prestador_interno_id)) {

            if (DB::table('exame_laboratorial_agendamento')->where('regulacao_solicitacao_id', $data->solicitacao_id)->exists()) {

                $data = DB::table('exame_laboratorial_agendamento as agendamento')
                    ->leftJoin('cadastro_unidade as unidade_coleta', 'unidade_coleta.id', 'agendamento.coleta_unidade_id')
                    ->leftJoin('cadastro_lotacao as lotacao_coleta', 'lotacao_coleta.id', 'agendamento.lotacao_id')
                    ->leftJoin('cadastro_usuario as usuario_coleta', 'usuario_coleta.id', DB::raw('COALESCE(lotacao_coleta.usuario_id, agendamento.usuario_id)'))
                    ->leftJoin('cadastro_cidadao as cidadao_coleta', 'cidadao_coleta.id', 'usuario_coleta.cidadao_id')
                    ->leftJoin('sigtap.ocupacao as ocupacao_coleta', 'ocupacao_coleta.id', DB::raw('COALESCE(lotacao_coleta.ocupacao_id, agendamento.ocupacao_id)'))
                    ->where('agendamento.regulacao_solicitacao_id', $data->solicitacao_id)
                    ->select(
                        'agendamento.data',
                        'unidade_coleta.nome_fantasia as unidade_coleta_nome_fantasia',
                        'ocupacao_coleta.codigo as ocupacao_coleta_codigo',
                        'cidadao_coleta.nome as usuario_coleta_nome',
                    )
                    ->first();

                $item->data_agendada = $data->data;
                $item->unidade_executora = $data->unidade_coleta_nome_fantasia;
                $item->ocupacao_executora = $data->ocupacao_coleta_codigo;
                $item->usuario_executor = $data->usuario_coleta_nome;
            }
            else if (DB::table('exame_imagem_agendamento')->where('regulacao_solicitacao_id', $data->solicitacao_id)->exists()) {

                $data = DB::table('exame_imagem_agendamento as agendamento')
                    ->join('cadastro_unidade as unidade_executante', 'unidade_executante.id', 'agendamento.unidade_id')
                    ->join('cadastro_usuario as usuario_executante', 'usuario_executante.id', 'agendamento.profissional_id')
                    ->join('cadastro_cidadao as cidadao_executante', 'cidadao_executante.id', 'usuario_executante.cidadao_id')
                    ->leftJoin('exame_imagem_fechamento_faturamento as fechamento', fn ($j) => $j
                        ->on('fechamento.agendamento_id', 'agendamento.id')
                        ->where('fechamento.exame_id', $item->exame_id)
                    )
                    ->leftJoin('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'fechamento.ocupacao_id')
                    ->where('agendamento.regulacao_solicitacao_id', $data->solicitacao_id)
                    ->select(
                        'agendamento.id as agendamento_id',
                        'agendamento.data',
                        'unidade_executante.nome_fantasia as unidade_executante_nome_fantasia',
                        'cidadao_executante.nome as usuario_executante_nome',
                        'ocupacao.codigo as ocupacao_executante_codigo'
                    )
                    ->first();

                $item->data_agendada = $data->data;
                $item->unidade_executora = $data->unidade_executante_nome_fantasia;
                $item->ocupacao_executora = $data->ocupacao_executante_codigo;
                $item->usuario_executor = $data->usuario_executante_nome;
            }
        }
        else if (!is_null($data->prestador_externo_id)) {

            $item->data_agendada = $data->data_agendada;

            if ($data->status_tipo_id === StatusTipo::REALIZADO) {

                $item->unidade_executora = $data->destino_descricao;
                $item->ocupacao_executora = $data->ocupacao_executora_codigo;
                $item->usuario_executor = $data->usuario_executor_nome;
            }
        }
    }

    private static function setExameLaboratorialData($item)
    {
        $data = DB::table('exame_laboratorial_agendamento_exame as item')
            ->join('exame_laboratorial_agendamento_exame_status as status', 'status.id', 'item.status_id')
            ->join('exame_laboratorial_agendamento as agendamento', 'agendamento.id', 'item.agendamento_id')
            ->leftJoin('cadastro_unidade as unidade_coleta', 'unidade_coleta.id', 'agendamento.coleta_unidade_id')
            ->leftJoin('cadastro_lotacao as lotacao_coleta', 'lotacao_coleta.id', 'agendamento.lotacao_id')
            ->leftJoin('cadastro_usuario as usuario_coleta', 'usuario_coleta.id', DB::raw('COALESCE(lotacao_coleta.usuario_id, agendamento.usuario_id)'))
            ->leftJoin('cadastro_cidadao as cidadao_coleta', 'cidadao_coleta.id', 'usuario_coleta.cidadao_id')
            ->leftJoin('sigtap.ocupacao as ocupacao_coleta', 'ocupacao_coleta.id', DB::raw('COALESCE(lotacao_coleta.ocupacao_id, agendamento.ocupacao_id)'))
            ->where('item.soap_solicitacao_exame_item_id', $item->id)
            ->select(
                'status.descricao as status_descricao',
                'agendamento.data',
                'unidade_coleta.nome_fantasia as unidade_coleta_nome_fantasia',
                'ocupacao_coleta.codigo as ocupacao_coleta_codigo',
                'cidadao_coleta.nome as usuario_coleta_nome',
            )
            ->first();

        $item->status = $data->status_descricao;
        $item->data_agendada = $data->data;
        $item->unidade_executora = $data->unidade_coleta_nome_fantasia;
        $item->ocupacao_executora = $data->ocupacao_coleta_codigo;
        $item->usuario_executor = $data->usuario_coleta_nome;
    }

    private static function setExameImagemData($item)
    {
        $data = DB::table('exame_imagem_agendamento_exame as agendamento_exame')
            ->join('exame_imagem_fechamento_status as status', 'status.id', 'agendamento_exame.status_id')
            ->join('exame_imagem_agendamento as agendamento', 'agendamento.id', 'agendamento_exame.agendamento_id')
            ->join('cadastro_unidade as unidade_executante', 'unidade_executante.id', 'agendamento.unidade_id')
            ->join('cadastro_usuario as usuario_executante', 'usuario_executante.id', 'agendamento.profissional_id')
            ->join('cadastro_cidadao as cidadao_executante', 'cidadao_executante.id', 'usuario_executante.cidadao_id')
            ->leftJoin('exame_imagem_fechamento_faturamento as fechamento', 'fechamento.agendamento_exame_id', 'agendamento_exame.id')
            ->leftJoin('sigtap.ocupacao as ocupacao', 'ocupacao.id', 'fechamento.ocupacao_id')
            ->where('agendamento_exame.soap_solicitacao_exame_item_id', $item->id)
            ->select(
                'status.nome as status_nome',
                'agendamento.data',
                'unidade_executante.nome_fantasia as unidade_executante_nome_fantasia',
                'cidadao_executante.nome as usuario_executante_nome',
                'ocupacao.codigo as ocupacao_executante_codigo'
            )
            ->first();

        $item->status = $data->status_nome;
        $item->data_agendada = $data->data;
        $item->unidade_executora = $data->unidade_executante_nome_fantasia;
        $item->ocupacao_executora = $data->ocupacao_executante_codigo;
        $item->usuario_executor = $data->usuario_executante_nome;
    }

    public static function createEncerramentoOci($acompanhamentoOciId)
    {
        $acompanhamentoOci = AcompanhamentoOci::findOrFail($acompanhamentoOciId);

        return [
            'additionals' => [
                'data_atual' => Carbon::now()->format('d/m/Y'),
            ],
            'form' => [
                'motivos' => AcompanhamentoOciMotivoEncerramento::orderBy('nome')->get(['id', 'nome']),
                'apac_motivos_saida_permanencia' => MotivoSaidaPermanencia::whereIn('id', [
                    ApacMotivoSaidaPermanencia::ALTA_CURADO,
                    ApacMotivoSaidaPermanencia::ALTA_MELHORADO,
                    ApacMotivoSaidaPermanencia::ALTA_A_PEDIDO,
                    ApacMotivoSaidaPermanencia::ALTA_COM_PREVISAO_DE_RETORNO_PARA_ACOMPANHAMENTO_DO_PACIENTE,
                ])->orderBy('nome')->get(['id', 'nome'])
            ],
            'model' => [
                'motivo_id' => null,
                'observacao' => null,
                'data_obito' => $acompanhamentoOci->paciente->cidadao->obito
                    ? $acompanhamentoOci->paciente->cidadao->obito->obito_em->format('d/m/Y')
                    : null,
                'apac_motivo_saida_permanencia_id' => null,
            ],
        ];
    }

    public static function storeEncerramentoOci($acompanhamentoOciId)
    {
        $acompanhamentoOci = AcompanhamentoOci::findOrFail($acompanhamentoOciId);

        self::validateStoreEncerramentoOci();

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

            $params = [
                'finalizado_em' => Carbon::now(),
                'finalizado_lotacao_id' => self::getCurrentLotacao()->id,
                'finalizado_motivo_encerramento_id' => request()->motivo_id,
                'finalizado_observacao' => request()->observacao,
                'status_id' => AcompanhamentoOciStatus::ENCERRADO_MANUALMENTE
            ];

            if (request()->motivo_id === AmbulatorioAcompanhamentoOciMotivoEncerramento::CONCLUIDO) {

                $params['motivo_saida_permanencia_id'] = request()->apac_motivo_saida_permanencia_id;
                $params['etapa_clinica_atual_id'] = EtapaClinica::ALTA;

                $acompanhamentoOci->etapasClinicasConcluidas()->create([
                    'etapa_clinica_id' => EtapaClinica::ALTA,
                ]);

                if (Carbon::now() <= self::getPrazoValidadeOci($acompanhamentoOci)) {

                    $cidsOci = self::getCidsOci($acompanhamentoOci->oci);

                    $soapEntrada = $acompanhamentoOci->etapasClinicasConcluidas()
                        ->where('etapa_clinica_id', EtapaClinica::ENTRADA)
                        ->first()
                        ->soap;

                    $problemaCondicao = $soapEntrada->problemasCondicoes()
                        ->whereHas('cid', fn ($q) => $q->whereIn('id', $cidsOci))
                        ->first();

                    $params = array_merge($params, [
                        'procedimento_oci_data' => Carbon::now(),
                        'procedimento_oci_procedimento_id' => $acompanhamentoOci->oci->procedimento->id,
                        'procedimento_oci_cid_id' => $problemaCondicao->cid_id,
                        'procedimento_oci_quantidade' => 1,
                        'procedimento_oci_ocupacao_id' => $soapEntrada->atendimento->ocupacao->id,
                        'procedimento_oci_usuario_id' => $soapEntrada->atendimento->usuario->id,
                    ]);
                }
            }

            $acompanhamentoOci->update($params);

            if (request()->motivo_id === AmbulatorioAcompanhamentoOciMotivoEncerramento::OBITO) {

                Obito::updateOrCreate(
                    ['cidadao_id' => $acompanhamentoOci->paciente->cidadao->id],
                    ['obito_em' => Carbon::createFromFormat('d/m/Y', request()->data_obito)],
                );

                ObitoService::saveHistorico($acompanhamentoOci->paciente_id);
            }
        });

        return $acompanhamentoOci->fresh();
    }

    private static function getPrazoValidadeOci($acompanhamentoOci)
    {
        return $acompanhamentoOci->iniciado_em->copy()->addMonth()->endOfMonth()->endOfDay();
    }

    private static function getCidsOci($oci)
    {
        return DB::table('sigtap.cid AS cid')
            ->whereExists(fn ($q) => $q
                ->selectRaw(1)
                ->from('sigtap.procedimento_cid AS procedimento_cid')
                ->join('sigtap.procedimento AS procedimento', 'procedimento.id', 'procedimento_cid.procedimento_id')
                ->whereColumn('procedimento_cid.cid_id', 'cid.id')
                ->where('procedimento_cid.competencia_id', DB::table('sigtap.competencia')->max('id'))
                ->where('procedimento.codigo', $oci->procedimento_codigo)
            )
            ->select('cid.id')
            ->get()
            ->pluck('id');
    }

    private static function validateStoreEncerramentoOci()
    {
        request()->validate([
            'motivo_id' => [
                'required',
                'integer',
                Rule::exists(AcompanhamentoOciMotivoEncerramento::class, 'id')
            ],
            'observacao' => [
                'nullable',
                'string',
                'min:150',
                'max:500'
            ],
            'data_obito' => [
                'nullable',
                Rule::requiredIf(fn () => request()->motivo_id === AmbulatorioAcompanhamentoOciMotivoEncerramento::OBITO),
                'date_format:d/m/Y'
            ],
            'apac_motivo_saida_permanencia_id' => [
                'nullable',
                Rule::requiredIf(fn () => request()->motivo_id === AmbulatorioAcompanhamentoOciMotivoEncerramento::CONCLUIDO),
                'integer',
                Rule::exists(MotivoSaidaPermanencia::class, 'id'),
            ],
        ]);
    }

    public static function dadosProcedimentosPreenchidos($acompanhamentoOciId)
    {
        $acompanhamentoOci = AcompanhamentoOci::findOrFail($acompanhamentoOciId);

        $procedimentosOci = $acompanhamentoOci->oci->procedimentosPrimarios->pluck('procedimento_codigo')
            ->concat($acompanhamentoOci->oci->procedimentosSecundarios->pluck('procedimento_codigo'));

        $dadosPreenchidos = true;

        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('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',
                'solicitacao_exame_item.status_id as externo_nao_regulado_status_id',
            )
            ->get()
            ->each(function ($item) use (&$dadosPreenchidos) {

                $regulacaoSolicitacaoItem = DB::table('regulacao_solicitacao_item as item')
                    ->join('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'item.solicitacao_id')
                    ->join('regulacao_status as status', 'status.id', 'solicitacao.status_id')
                    ->join('regulacao_status_tipo as status_tipo', 'status_tipo.id', 'status.tipo_id')
                    ->where('item.soap_solicitacao_item_id', $item->id)
                    ->select(
                        'status_tipo.id as status_tipo_id',
                    )
                    ->first();

                if (!is_null($regulacaoSolicitacaoItem)) {

                    if ($regulacaoSolicitacaoItem->status_tipo_id !== StatusTipo::REALIZADO) {

                        $dadosPreenchidos = false;

                        return false;
                    }

                    return true;
                }

                $exameLaboratorialAgendamentoItem = DB::table('exame_laboratorial_agendamento_exame as item')
                    ->where('item.soap_solicitacao_exame_item_id', $item->id)
                    ->select(
                        'item.status_id',
                    )
                    ->first();

                if (!is_null($exameLaboratorialAgendamentoItem)) {

                    if (!collect([
                        StatusAgendamento::REALIZADO,
                        StatusAgendamento::PENDENTE_ASSINATURA,
                        StatusAgendamento::ASSINADO,
                        StatusAgendamento::PENDENTE_ENTREGA,
                        StatusAgendamento::ENTREGUE,
                    ])->contains($exameLaboratorialAgendamentoItem->status_id)) {

                        $dadosPreenchidos = false;

                        return false;
                    }

                    return true;
                }

                $exameImagemItem = DB::table('exame_imagem_agendamento_exame as agendamento_exame')
                    ->leftJoin('exame_imagem_fechamento_faturamento as fechamento', 'fechamento.agendamento_exame_id', 'agendamento_exame.id')
                    ->where('agendamento_exame.soap_solicitacao_exame_item_id', $item->id)
                    ->select(
                        'fechamento.id as fechamento_id',
                    )
                    ->first();

                if (!is_null($exameImagemItem)) {

                    if (is_null($exameImagemItem->fechamento_id)) {

                        $dadosPreenchidos = false;

                        return false;
                    }

                    return true;
                }

                if ($item->externo_nao_regulado_status_id !== AmbulatorioAtendimentoSoapSolicitacaoExameItemStatus::REALIZADO) {

                    $dadosPreenchidos = false;
                }
            });

        if ($dadosPreenchidos) {

            DB::table('ambulatorio_acompanhamento_oci_procedimento_realizado AS procedimento_realizado')
                ->where('procedimento_realizado.acompanhamento_oci_id', $acompanhamentoOci->id)
                ->select(
                    'procedimento_realizado.data_executada',
                    'procedimento_realizado.unidade_executora_id',
                    'procedimento_realizado.ocupacao_executora_id',
                )
                ->get()
                ->each(function ($procedimentoRealizado) use (&$dadosPreenchidos) {

                    if (is_null($procedimentoRealizado->data_executada)
                        || is_null($procedimentoRealizado->unidade_executora_id)
                        || is_null($procedimentoRealizado->ocupacao_executora_id)
                    ) {

                        $dadosPreenchidos = false;

                        return false;
                    }
                });
        }

        return $dadosPreenchidos;
    }
}