<?php

namespace App\Services\Ambulatorio;


use App\Enums\Ambulatorio\AgendamentoStatus as AgendamentoStatusEnum;
use App\Enums\AtencaoBasica\AtendimentoIndividual\LocalAtendimento as EnumsLocalAtendimento;
use App\Enums\Geral\Turno as TurnoEnum;
use App\Enums\Regulacao\StatusTipo as RegulacaoStatusTipoEnum;
use App\Enums\Sigtap\Procedimento as EnumsSigtapProcedimento;
use App\Enums\Sigtap\Registro;
use App\Exceptions\Ambulatorio\NaoPodeCriarFichaAtencaoBasicaException;
use App\Exceptions\Ambulatorio\ProtocoloFechamentoException;
use App\Models\Administracao\Funcionalidade;
use App\Models\Ambulatorio\Agendamento;
use App\Models\Ambulatorio\AgendamentoStatus;
use App\Models\Ambulatorio\Atendimento;
use App\Models\Ambulatorio\AtendimentoSoap;
use App\Models\Ambulatorio\ParametrizacaoInfraestruturaEspecialidadeProcedimento;
use App\Models\Ambulatorio\ParametrizacaoInfraestruturaOcupacao;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\LocalAtendimento;
use App\Models\Cadastro\Especialidade;
use App\Models\Cadastro\Estabelecimento\Infraestrutura;
use App\Models\Cadastro\Estabelecimento\Unidade;
use App\Models\Cadastro\SujeitoAtencao\Paciente;
use App\Models\Cadastro\SujeitoAtencao\Usuario;
use App\Models\Cns\TermoInvalido;
use App\Models\Geral\Turno;
use App\Models\Sigtap\Competencia;
use App\Models\Sigtap\Procedimento;
use App\Services\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualService;
use App\Services\AtencaoBasica\AtendimentoOdontologico\AtendimentoOdontologicoService;
use App\Services\AtencaoBasica\Procedimento\ProcedimentoService;
use App\Services\Regulacao\SolicitacaoService as RegulacaoSolicitacaoService;
use App\Services\Service;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use Exception;
use Illuminate\Support\Facades\DB;

class FechamentoConsultaService extends Service
{

    public static function index($params)
    {

        if (!request()->tipo_atendimento || request()->tipo_atendimento === 'agendamento') {


            $agendamentos = DB::table('ambulatorio_agendamento as agendamento')
                ->join(
                    'ambulatorio_agendamento_status as status',
                    'status.id',
                    'agendamento.status_id'
                )
                ->join(
                    'ambulatorio_agendamento_tipo as tipo',
                    'tipo.id',
                    'agendamento.tipo_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(
                    'cadastro_unidade as unidade',
                    'unidade.id',
                    'infraestrutura.unidade_id'
                )
                ->join(
                    'cadastro_usuario as usuario',
                    'usuario.id',
                    'lotacao.usuario_id'
                )
                ->join(
                    'cadastro_cidadao as cidadao',
                    'cidadao.id',
                    'usuario.cidadao_id'
                )
                ->join(
                    'sigtap.ocupacao as ocupacao',
                    'ocupacao.id',
                    'lotacao.ocupacao_id'
                )
                ->join(
                    'cadastro_especialidade as especialidade',
                    'especialidade.id',
                    'jornada.especialidade_id'
                )
                ->join(
                    'cadastro_lotacao as lotacao_agendamento',
                    'lotacao_agendamento.id',
                    'agendamento.created_lotacao_id'
                )
                ->join(
                    'cadastro_usuario as usuario_agendamento',
                    'usuario_agendamento.id',
                    'lotacao_agendamento.usuario_id'
                )
                ->join(
                    'cadastro_cidadao as cidadao_agendamento',
                    'cidadao_agendamento.id',
                    'usuario_agendamento.cidadao_id'
                )
                ->join(
                    'cadastro_paciente as paciente_agendamento',
                    'paciente_agendamento.id',
                    'agendamento.paciente_id'
                )
                ->join(
                    'cadastro_cidadao as cidadao_paciente',
                    'cidadao_paciente.id',
                    'paciente_agendamento.cidadao_id'
                )
                ->leftJoin('regulacao_solicitacao as solicitacao', 'solicitacao.id', 'agendamento.regulacao_solicitacao_id')
                ->leftJoin('regulacao_parametrizacao_prestador_interno as prestador_interno', 'prestador_interno.id', 'solicitacao.prestador_interno_id')
                ->leftJoin('ambulatorio_atendimento as atendimento', 'atendimento.agendamento_id', 'agendamento.id')
                ->where('agendamento.status_id', AgendamentoStatusEnum::AGENDADO)
                ->when($params->data ?? null, fn ($q, $data) => $q
                    ->where('jornada.data', $data)
                )
                ->when($params->unidade_id ?? null, fn ($q, $id) => $q->where('unidade.id', $id))
                ->when($params->infraestrutura_id ?? null, fn ($q, $id) => $q->where('infraestrutura.id', $id))
                ->when($params->ocupacao_id ?? null, fn ($q, $id) => $q->where('ocupacao.id', $id))
                ->when($params->especialidade_id ?? null, fn ($q, $id) => $q->where('especialidade.id', $id))
                ->when($params->usuario_id ?? null, fn ($q, $id) => $q->where('usuario.id', $id))
                ->when($params->tipo_id ?? null, fn ($q, $id) => $q->where('tipo.id', $id))
                ->when($params->status_id ?? null, fn ($q, $id) => $q->where('status.id', $id))
                ->select(DB::raw("
                    agendamento.id as agendamento_id,
                    atendimento.id as atendimento_id,
                    agendamento.paciente_id as paciente_id,
                    jornada.data,
                    DATE_FORMAT(agendamento.horario, '%H:%i') as horario,
                    unidade.nome_fantasia as unidade,
                    COALESCE(infraestrutura.nome, unidade.nome_fantasia) as infraestrutura,
                    cidadao.nome as usuario_nome,
                    usuario.id as usuario_id,
                    infraestrutura.id as infraestrutura_id,
                    unidade.id as unidade_id,
                    ocupacao.id as ocupacao_id,
                    CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) as ocupacao,
                    especialidade.nome as especialidade,
                    especialidade.id as especialidade_id,
                    especialidade.permite_fechamento_sem_procedimento as especialidade_sem_proc,
                    especialidade.atencao_basica_procedimento_padrao_codigo as especialidade_atencao_basica_procedimento_padrao_codigo,
                    NULL as status_id,
                    NULL as cid,
                    NULL as procedimento,
                    NULL as quantidade,
                    ".EnumsLocalAtendimento::UBS." as atencao_basica_local_atendimento_id,
                    cidadao_agendamento.nome as usuario_agendamento,
                    DATE_FORMAT(agendamento.created_at, '%d/%m/%Y às %H:%i') as data_hora_agendamento,
                    cidadao_paciente.nome as cidadao_paciente_nome,
                    cidadao_paciente.nome_social as cidadao_paciente_nome_social,
                    LPAD(paciente_agendamento.prontuario,7,'0') as prontuario,
                    cidadao_paciente.data_nascimento as cidadao_paciente_data_nascimento,
                    cidadao_paciente.cpf as cidadao_paciente_cpf,
                    cidadao_paciente.cns as cidadao_paciente_cns,
                    cidadao_paciente.preferencia_nome_id,
                    cidadao_paciente.sexo_id as cidadao_paciente_sexo_id,
                    IF (cidadao_paciente.nome_mae IS NULL, 'Não informado', cidadao_paciente.nome_mae) as cidadao_paciente_nome_mae,
                    'Agendamento' as tipo_atendimento,
                    agendamento.regulacao_solicitacao_id,
                    solicitacao.numero,
                    CASE
                        WHEN controla_protocolo_fechamento IS NULL THEN NULL
                        WHEN controla_protocolo_fechamento = 0 THEN NULL
                        ELSE controla_protocolo_fechamento
                    END AS controla_protocolo_fechamento
                "))
                ->get()
                ->toArray();
        }

        if (!request()->tipo_atendimento || request()->tipo_atendimento === 'demanda_espontanea') {

            $atendimentos = DB::table('ambulatorio_atendimento as atendimento')
                ->join(
                    'cadastro_lotacao as lotacao',
                    'lotacao.id',
                    'atendimento.created_lotacao_id'
                )
                ->leftJoin(
                    'ambulatorio_demanda_espontanea as demanda_espontanea',
                    'demanda_espontanea.id',
                    'atendimento.demanda_espontanea_id'
                )
                ->join(
                    'cadastro_infraestrutura as infraestrutura',
                    'infraestrutura.id',
                    'lotacao.infraestrutura_id'
                )
                ->join(
                    'cadastro_unidade as unidade',
                    'unidade.id',
                    'infraestrutura.unidade_id'
                )
                ->leftJoin(
                    'cadastro_usuario as usuario',
                    'usuario.id',
                    'demanda_espontanea.usuario_id'
                )
                ->leftJoin(
                    'cadastro_cidadao as cidadao',
                    'cidadao.id',
                    'usuario.cidadao_id'
                )
                ->leftJoin(
                    'cadastro_especialidade as especialidade',
                    'especialidade.id',
                    'demanda_espontanea.especialidade_id'
                )
                ->leftJoin(
                    'sigtap.ocupacao as ocupacao',
                    'ocupacao.id',
                    'especialidade.ocupacao_id'
                )
                ->join(
                    'cadastro_usuario as usuario_atendimento',
                    'usuario_atendimento.id',
                    'lotacao.usuario_id'
                )
                ->join(
                    'cadastro_cidadao as cidadao_atendimento',
                    'cidadao_atendimento.id',
                    'usuario_atendimento.cidadao_id'
                )
                ->join(
                    'painel_senha_fila as fila',
                    'fila.id',
                    'atendimento.fila_id'
                )
                ->join(
                    'cadastro_paciente as paciente_atendimento',
                    'paciente_atendimento.id',
                    'fila.paciente_id'
                )
                ->join(
                    'cadastro_cidadao as cidadao_paciente',
                    'cidadao_paciente.id',
                    'paciente_atendimento.cidadao_id'
                )
                ->whereNotNull('fila.id')
                ->whereNotNull('atendimento.demanda_espontanea_id')
                ->whereNull('atendimento.finalizado_em')
                ->when($params->data ?? null, fn ($q, $data) => $q
                    ->whereDate('atendimento.created_at', '=', $data)
                )
                ->where('fila.evadido', false)
                ->when($params->unidade_id ?? null, fn ($q, $id) => $q->where('unidade.id', $id))
                ->when($params->infraestrutura_id ?? null, fn ($q, $id) => $q->where('infraestrutura.id', $id))
                ->when($params->ocupacao_id ?? null, fn ($q, $id) => $q->where('ocupacao.id', $id))
                ->when($params->especialidade_id ?? null, fn ($q, $id) => $q->where('especialidade.id', $id))
                ->when($params->usuario_id ?? null, fn ($q, $id) => $q->where('usuario.id', $id))
                ->select(DB::raw("
                    NULL as agendamento_id,
                    atendimento.id as atendimento_id,
                    fila.paciente_id as paciente_id,
                    DATE_FORMAT(atendimento.created_at, '%Y-%m-%d') as data,
                    DATE_FORMAT(atendimento.created_at, '%H:%i') as horario,
                    unidade.nome_fantasia as unidade,
                    COALESCE(infraestrutura.nome, unidade.nome_fantasia) as infraestrutura,
                    cidadao.nome as usuario_nome,
                    usuario.id as usuario_id,
                    infraestrutura.id as infraestrutura_id,
                    unidade.id as unidade_id,
                    ocupacao.id as ocupacao_id,
                    CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) as ocupacao,
                    especialidade.nome as especialidade,
                    especialidade.id as especialidade_id,
                    especialidade.permite_fechamento_sem_procedimento as especialidade_sem_proc,
                    especialidade.atencao_basica_procedimento_padrao_codigo as especialidade_atencao_basica_procedimento_padrao_codigo,
                    NULL as status_id,
                    NULL as cid,
                    NULL as procedimento,
                    NULL as quantidade,
                    ".EnumsLocalAtendimento::UBS." as atencao_basica_local_atendimento_id,
                    cidadao_atendimento.nome as usuario_agendamento,
                    DATE_FORMAT(atendimento.created_at, '%d/%m/%Y às %H:%i') as data_hora_agendamento,
                    cidadao_paciente.nome as cidadao_paciente_nome,
                    cidadao_paciente.nome_social as cidadao_paciente_nome_social,
                    LPAD(paciente_atendimento.prontuario,7,'0') as prontuario,
                    cidadao_paciente.data_nascimento as cidadao_paciente_data_nascimento,
                    cidadao_paciente.cpf as cidadao_paciente_cpf,
                    cidadao_paciente.cns as cidadao_paciente_cns,
                    cidadao_paciente.preferencia_nome_id,
                    cidadao_paciente.sexo_id as cidadao_paciente_sexo_id,
                    IF (cidadao_paciente.nome_mae IS NULL, 'Não informado', cidadao_paciente.nome_mae) as cidadao_paciente_nome_mae,
                    'Demanda espontânea' as tipo_atendimento
                "))
                ->get()
                ->toArray();
        }

        if (!request()->tipo_atendimento) {
        $consultas = array_merge($agendamentos, $atendimentos);
        } else if (request()->tipo_atendimento === 'demanda_espontanea') {

            $consultas = $atendimentos;
        } else if (request()->tipo_atendimento === 'agendamento') {

            $consultas = $agendamentos;
        }

        foreach ($consultas as $consulta) {

            $procedimentoAtendimento = DB::table('ambulatorio_atendimento_procedimento as atendimento_procedimento')
                ->join(
                    'sigtap.procedimento as procedimento',
                    'procedimento.id',
                    'atendimento_procedimento.procedimento_id'
                )
                ->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'
                )
                ->where('atendimento_id', $consulta->atendimento_id)
                ->orderBy('procedimento.competencia_id', 'desc')
                ->select(
                    "procedimento.id as id",
                    "procedimento.codigo as codigo",
                    "procedimento.nome as nome",
                    "lotacao.usuario_id as usuario_id"
                )
                ->get();

                $consulta->procedimentos_atendimento = $procedimentoAtendimento->map(function ($item) {
                    return (object)[
                        'id' => $item->id,
                        'codigo' => $item->codigo,
                        'nome' => $item->nome,
                        'usuario_id' => $item->usuario_id
                    ];
                })->toArray();

            $cidadao_paciente_idade_anos = (int) Carbon::create($consulta->cidadao_paciente_data_nascimento)->diff(Carbon::now())->format('%y');
            $cidadao_agendamento_idade_meses = (int) Carbon::create($consulta->cidadao_paciente_data_nascimento)->diff(Carbon::now())->format('%m');
            $cidadao_paciente_idade_dias = (int) Carbon::create($consulta->cidadao_paciente_data_nascimento)->diff(Carbon::now())->format('%d');

            $cidadao_paciente_idade = $cidadao_paciente_idade_anos . ' anos,  '
                . $cidadao_agendamento_idade_meses . ' meses e '
                . $cidadao_paciente_idade_dias . ' dias';

            $consulta->cidadao_paciente_idade = $cidadao_paciente_idade;
            $consulta->cidadao_paciente_idade_anos = $cidadao_paciente_idade_anos;
            $consulta->cidadao_paciente_data_nascimento_formatada = Carbon::create($consulta->cidadao_paciente_data_nascimento)->format('d/m/Y');
            $consulta->cidadao_paciente_cpf = MaskUtil::getCpfMasked($consulta->cidadao_paciente_cpf);
            $consulta->cidadao_paciente_cns = MaskUtil::getCnsMasked($consulta->cidadao_paciente_cns);

            $consulta->ocupacoes_jornada = [];
            $consulta->procedimentos = self::getProcedimentosPadroes($consulta);
            $consulta->especialidades_jornada = [];
            $consulta->usuarios_jornada = [];
            $consulta->turno_id = self::getTurnoMomento($consulta->horario);

            $consulta->cria_ficha_atendimento_individual = $consulta->ocupacao_id
                ? self::criaFicha($consulta->infraestrutura_id, $consulta->ocupacao_id, 'atendimento-individual') : false;

            $consulta->cria_ficha_atendimento_odontologico = $consulta->ocupacao_id
                ? self::criaFicha($consulta->infraestrutura_id, $consulta->ocupacao_id, 'atendimento-odontologico') : false;

            $consulta->cadastro = [
                'dataUsuarioResponsavel' => $consulta->data,
                'usuario' => [
                    'id' => $consulta->usuario_id,
                    'cidadao_nome' => $consulta->usuario_nome
                ],
                'unidade_id' => $consulta->unidade_id,
                'infraestrutura_id' => $consulta->infraestrutura_id,
                'equipe_id' => null,
                'ocupacao_id' => $consulta->ocupacao_id
            ];
            $consulta->protocolo_fechamento = null;
        }

        return [
            'consultas' => $consultas,
            'especialidades' => self::getEspecialidadesWithJornada(),
        ];
    }

    private static function getProcedimentosPadroes($atendimento)
    {

        if ($atendimento->especialidade) {

            $procedimentosParametrizados = self::getProcedimentosParametrizados($atendimento);

            if ($procedimentosParametrizados->isNotEmpty()) {

                return $procedimentosParametrizados;
            }
            else if ($atendimento->especialidade_atencao_basica_procedimento_padrao_codigo) {

                $especialidade = $atendimento->especialidade_id
                    ? Especialidade::where('id', $atendimento->especialidade_id)->first()
                    : null;

                 $equipe = DB::table('atencao_basica_parametrizacao_equipe as equipe')
                    ->join(
                        'atencao_basica_parametrizacao_equipe_usuario as equipe_usuario',
                        'equipe_usuario.equipe_id',
                        'equipe.id')
                    ->join(
                        'ambulatorio_parametrizacao_infraestrutura as infr',
                        'infr.infraestrutura_id',
                        'equipe.infraestrutura_id')
                    ->join(
                        'ambulatorio_parametrizacao_infraestrutura_ocupacao as ocup',
                        'ocup.parametrizacao_infraestrutura_id',
                        'infr.id')
                    ->join(
                        'atencao_basica_parametrizacao_area as area',
                        'area.id',
                        'equipe.area_id')
                    ->where('equipe_usuario.usuario_id', $atendimento->usuario_id)
                    ->where('equipe.infraestrutura_id', $atendimento->infraestrutura_id)
                    ->where('equipe.unidade_id', $atendimento->unidade_id)
                    ->where('ocup.ocupacao_id', $atendimento->ocupacao_id)
                    ->select([
                        'equipe.id as equipe_id',
                        'area.numero_ine as codigo_equipe'
                    ])
                    ->first();

                return collect([
                    [

                        'id' => $especialidade ? $especialidade->atencao_basica_procedimento_padrao->id : null,
                        'codigo' => $especialidade ? $especialidade->atencao_basica_procedimento_padrao->codigo : null,
                        'nome' => $especialidade ? $especialidade->atencao_basica_procedimento_padrao->nome : null,
                        'has_instrumento_registro_raas' => $especialidade ? $especialidade->atencao_basica_procedimento_padrao
                            ->registros()
                            ->whereIn('codigo', [Registro::RAAS_ATENCAO_DOMICILIAR, Registro::RAAS_ATENCAO_PSICOSSOCIAL])
                            ->exists() : null,
                        'has_cid_principal' => $especialidade ? $especialidade->atencao_basica_procedimento_padrao->has_cid_principal : null,
                        'quantidade_maxima_execucao' => $especialidade ? $especialidade->atencao_basica_procedimento_padrao->quantidade_maxima_execucao : null,
                        'cid' => null,
                        'quantidade' => 1,
                        'automatico' => true,
                        'padrao' => false,
                        'origem' => 'ambulatorio',
                        'usuario' => [
                            'cidadaoNome' => $atendimento->usuario_nome,
                            'id' => $atendimento->usuario_id,
                        ],
                        'usuarioId' => $atendimento->usuario_id,
                        'ocupacaoId' => $atendimento->ocupacao_id,
                        'ocupacao' => $atendimento->ocupacao,
                        'equipeId' =>  $equipe ? $equipe->equipe_id : null,
                        'equipe' => $equipe ? $equipe->codigo_equipe : null,
                    ]
                ]);
            }
        }

        return collect();
    }

    private static function getProcedimentosParametrizados($atendimento)
    {
        return ParametrizacaoInfraestruturaEspecialidadeProcedimento::whereHas(
                'parametrizacaoInfraestruturaEspecialidade',
                fn ($q) => $q
                    ->where('especialidade_id', $atendimento->especialidade_id)
                    ->whereHas('parametrizacaoInfraestrutura', fn ($q) => $q
                        ->where('infraestrutura_id', $atendimento->infraestrutura_id)
                    )
            )
            ->get()
            ->map(fn ($parametrizacaoProcedimento) => [
                'id' => $parametrizacaoProcedimento->procedimento->id,
                'codigo' => $parametrizacaoProcedimento->procedimento->codigo,
                'nome' => $parametrizacaoProcedimento->procedimento->nome,
                'has_instrumento_registro_raas' => $parametrizacaoProcedimento->procedimento
                    ->registros()
                    ->whereIn('codigo', [Registro::RAAS_ATENCAO_DOMICILIAR, Registro::RAAS_ATENCAO_PSICOSSOCIAL])
                    ->exists(),
                'has_cid_principal' => $parametrizacaoProcedimento->procedimento->has_cid_principal,
                'quantidade_maxima_execucao' => $parametrizacaoProcedimento->procedimento->quantidade_maxima_execucao,
                'cid' => null,
                'quantidade' => 1,
                'automatico' => true,
                'padrao' => false,
                'origem' => 'ambulatorio',
                'usuario' => [
                    'cidadaoNome' => $atendimento->usuario_nome,
                    'id' => $atendimento->usuario_id,
                ],
                'usuarioId' => $atendimento->usuario_id,
                'ocupacaoId' => $atendimento->ocupacao_id,
                'ocupacao' => $atendimento->ocupacao,
                'equipeId' => null,
                'equipe' => null,
            ]);
    }

    public static function getEspecialidadesWithJornada()
    {
        return Especialidade::whereHas('ambulatorioJornadas', fn ($q) => $q
                ->whereNull('situacao_id')
                ->whereDate('data', request()->data)
                ->whereHas('lotacao', fn ($q) => $q
                    ->where('infraestrutura_id', request()->infraestrutura_id)
                )
            )
            ->when(request()->paciente_nao_municipe, fn ($q) => $q
                ->where('permite_agendamento_nao_municipe', true)
            )
            ->get(['id', 'nome', 'ocupacao_id', 'sexo_id', 'idade_minima', 'idade_maxima'])
            ->map(fn ($especialidade) => [
                'id' => $especialidade->id,
                'nome' => $especialidade->nome,
                'sexo_id' => $especialidade->sexo_id,
                'idade_minima' => $especialidade->idade_minima,
                'idade_maxima' => $especialidade->idade_maxima,
                'ocupacao' => $especialidade->ocupacao,
                'cria_ficha_atendimento_individual' =>  $especialidade->ocupacao
                    ? self::criaFicha(request()->infraestrutura_id, $especialidade->ocupacao->id, 'atendimento-individual')
                    : false,
                'cria_ficha_atendimento_odontologico' =>  $especialidade->ocupacao
                    ? self::criaFicha(request()->infraestrutura_id, $especialidade->ocupacao->id, 'atendimento-odontologico')
                    : false
            ])
            ->sortBy('nome')
            ->values();
    }

    public static function getUsuariosWithJornada()
    {
        return Usuario::setEagerLoads([])
            ->whereHas('lotacoes', fn ($q) => $q
                ->where('infraestrutura_id', request()->infraestrutura_id)
                ->whereHas('ambulatorioJornadas', fn ($q) => $q
                    ->whereNull('situacao_id')
                    ->whereDate('data', request()->data)
                    ->where('especialidade_id', request()->especialidade_id)
                )
            )
            ->get(['id', 'cidadao_id'])
            ->map(fn ($usuario) => [
                'id' => $usuario->id,
                'nome' => $usuario->cidadao()->setEagerLoads([])->first(['nome'])->nome,
            ])
            ->sortBy('nome')
            ->values();
    }

    private static function getTurnoMomento($horario)
    {
        $hora = substr($horario, 0, 2);
        $isManha = fn () => $hora >= 6 && $hora <= 11;
        $isTarde = fn () => $hora >= 12 && $hora <= 17;

        if ($isManha()) {

            return TurnoEnum::MANHA;
        }
        else if ($isTarde()) {

            return TurnoEnum::TARDE;
        }
        else {

            return TurnoEnum::NOITE;
        }
    }

    public static function create()
    {
        return self::getDadosCreateBusca();
    }

    private static function getDadosCreateBusca()
    {

        $formFilters = [
            'unidades' => [],
            'infraestruturas' => [],
            'ocupacoes' => [],
            'especialidades' => [],
            'usuarios' => [],
            'status' => [],
            'atencao_basica_equipes' => [],
            'equipes' => [],
            'tipos_atendimento' => [],
        ];

        $modelFilters = [
            'periodo' => [
                'start' => null,
                'end' => null,
            ],
            'inicio' => null,
            'fim' => null,
            'data' => null,
            'unidade_id' => null,
            'tipo_atendimento' => null,
            'infraestrutura_id' => null,
            'ocupacao_id' => null,
            'especialidade_id' => null,
            'usuario_id' => null,
            'tipo_id' => null,
            'status_id' => null,
            'procedimento' => null,
            'cid_principal' => null,
        ];

        $usuarioLogado = self::getCurrentLotacao();

        $agendamentosFilters = self::getAgendamentosFilters();

        $formFilters['local_atendimento'] = $agendamentosFilters->form['local_atendimento'];
        $formFilters['turnos'] = $agendamentosFilters->form['turnos'];
        $formFilters['procedimentos'] = $agendamentosFilters->form['procedimentos'];
        $formFilters['sigtap_competencias'] = $agendamentosFilters->form['sigtap_competencias'];
        $formFilters['administracao_medicamento'] = $agendamentosFilters->form['administracao_medicamento'];
        $formFilters['teste_rapido'] = $agendamentosFilters->form['teste_rapido'];
        $formFilters['procedimento_usuario'] = $agendamentosFilters->form['procedimento_usuario'];
        $formFilters['equipes'] = $agendamentosFilters->form['equipes'];
        $formFilters['tipos_atendimento'] = $agendamentosFilters->form['tipos_atendimento'];
        $formFilters['usuario_logado'] = $usuarioLogado;

        $modelFilters['status_id'] = $agendamentosFilters->model['status_id'];
        $modelFilters['data'] = $agendamentosFilters->model['data'];

        return [
            'additionals' => [
                'search_by_apelido' => false,
                'data_atual' => Carbon::now()->format('d/m/Y'),
                'status' => AgendamentoStatus::whereIn('id', [AgendamentoStatusEnum::FALTA_DO_PACIENTE, AgendamentoStatusEnum::FALTA_DO_MEDICO, AgendamentoStatusEnum::REALIZADO])->get(),
                'locais_atendimento' => LocalAtendimento::orderBy('descricao')->get(['id', 'descricao']),
            ],
            'form' => $formFilters,
            'model' => $modelFilters,
        ];
    }

    private static function getAgendamentosFilters()
    {

        return (object) [
            'form' => [
                'data_atual' => Carbon::now()->format('d/m/Y'),
                'termos_invalidos' => TermoInvalido::all()->map(fn ($termo) => $termo->descricao),
                'turnos' => Turno::orderBy('nome')->get(),
                'local_atendimento' => LocalAtendimento::whereNotIn('id', [
                        EnumsLocalAtendimento::HOSPITAL,
                        EnumsLocalAtendimento::UNIDADE_PRONTO_ATENDIMENTO,
                        EnumsLocalAtendimento::CACON_UNACON,
                    ])
                    ->orderBy('descricao')
                    ->get(),
                'procedimentos' => Procedimento::whereIn('codigo', [
                        EnumsSigtapProcedimento::MEDICAO_PESO,
                        EnumsSigtapProcedimento::MEDICAO_ALTURA,
                        EnumsSigtapProcedimento::AFERICAO_TEMPERATURA,
                        EnumsSigtapProcedimento::AFERICAO_PRESSAO_ARTERIAL,
                        EnumsSigtapProcedimento::AVALIACAO_ANTROPOMETRICA,
                        EnumsSigtapProcedimento::GLICEMIA_CAPILAR,
                        EnumsSigtapProcedimento::COLETA_DE_MATERIAL_PARA_EXAME_LABORATORIAL,
                    ])
                    ->where('competencia_id', function ($query) {
                        $query->select('sigtap.competencia.id')
                            ->from('sigtap.competencia')
                            ->orderByDesc('sigtap.competencia.valor')
                            ->limit(1);
                    })
                    ->groupBy('codigo')
                    ->get(),
                'sigtap_competencias' => Competencia::orderByDesc('valor')->take(4)->get(),
                'procedimento_pequena_cirurgia' => [],
                'administracao_medicamento' => [],
                'teste_rapido' => [],
                'procedimento_usuario' => [],
                'equipes' => [],
                'tipos_atendimento' => [
                    ['value' => 'agendamento', 'text' => 'AGENDAMENTO'],
                    ['value' => 'demanda_espontanea', 'text' => 'DEMANDA ESPONTÂNEA'],
                ],
            ],
            'model' => [
                'data' => Carbon::today()->format('Y-m-d'),
                'status_id' => null,
            ],
        ];
    }

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

            case 'busca': {

                return self::getDadosListBusca();
            }
        }
    }

    private static function getDadosListBusca()
    {
        $params = (object) request()->all();
        $params->data = request()->data ?? Carbon::now()->format('Y-m-d');

        switch (request()->listar) {

            case 'unidades': {

                return [
                    'unidades' => self::getBuscaUnidades($params),
                ];
            }
            case 'infraestruturas': {

                return [
                    'infraestruturas' => self::getBuscaInfraestruturas($params),
                ];

                return self::getBuscaInfraestruturas($params);
            }
            case 'especialidades': {

                return [
                    'especialidades' => self::getBuscaEspecialidades($params),
                ];
            }
            case 'usuarios': {

                return [
                    'usuarios' => self::getBuscaUsuarios($params),
                ];
            }
            case 'status': {

                return [
                    'status' => self::getBuscaStatus($params),
                ];
            }
        }
    }

    private static function getBuscaUnidades($params)
    {
        $query = Unidade::query()->orderBy('nome_fantasia');

        if (request()->tipo_atendimento === null || request()->tipo_atendimento === 'agendamento') {

            $query->whereHas('infraestruturas', function ($q) use ($params) {
                $q->whereHas('lotacoes', function ($q) use ($params) {
                    $q->whereHas('ambulatorioJornadas', function ($q) use ($params) {
                        $q->where('data', $params->data)
                            ->whereHas('agendamentos', function ($q) {
                                $q->where('status_id', AgendamentoStatusEnum::AGENDADO);
                            });
                    });
                });
            });
        }

        if (request()->tipo_atendimento === null || request()->tipo_atendimento === 'demanda_espontanea') {

            $query->orWhereHas('infraestruturas', function ($q) use ($params) {
                $q->whereExists(function ($query) use ($params) {
                    $query->select(DB::raw(1))
                        ->from('ambulatorio_atendimento')
                        ->join('painel_senha_fila', 'painel_senha_fila.id', 'ambulatorio_atendimento.fila_id')
                        ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'painel_senha_fila.centro_custo_id')
                        ->whereColumn('cadastro_centro_custo.infraestrutura_id', 'cadastro_infraestrutura.id')
                        ->where('painel_senha_fila.emitido_em', $params->data)
                        ->whereNull('ambulatorio_atendimento.finalizado_em')
                        ->whereNotNull('ambulatorio_atendimento.demanda_espontanea_id');
                });
            });
        }

        return $query->get(['id', 'nome_fantasia']);
    }

    private static function getBuscaInfraestruturas($params)
    {
        return Infraestrutura::setEagerLoads([])
            ->where('unidade_id', $params->unidade_id)
            ->where(function ($query) use ($params) {

                if (request()->tipo_atendimento === null || request()->tipo_atendimento === 'agendamento') {

                    $query->whereHas('lotacoes', function ($q) use ($params) {
                        $q->whereHas('ambulatorioJornadas', function ($q) use ($params) {
                            $q->where('data', $params->data)
                                ->whereHas('agendamentos', function ($q) {
                                    $q->where('status_id', AgendamentoStatusEnum::AGENDADO);
                                });
                        });
                    });
                }

                if (request()->tipo_atendimento === null || request()->tipo_atendimento === 'demanda_espontanea') {

                    $query->orWhereExists(function ($query) use ($params) {
                        $query->select(DB::raw(1))
                            ->from('ambulatorio_atendimento')
                            ->join('painel_senha_fila', 'painel_senha_fila.id', 'ambulatorio_atendimento.fila_id')
                            ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'painel_senha_fila.centro_custo_id')
                            ->whereColumn('cadastro_centro_custo.infraestrutura_id', 'cadastro_infraestrutura.id')
                            ->where('painel_senha_fila.emitido_em', $params->data)
                            ->whereNull('ambulatorio_atendimento.finalizado_em')
                            ->whereNotNull('ambulatorio_atendimento.demanda_espontanea_id');
                    });
                }
            })
            ->get(['id', 'nome', 'principal', 'unidade_id'])
            ->map(fn ($infraestrutura) => [
                'id' => $infraestrutura->id,
                'nome' => $infraestrutura->nome
            ])
            ->sortBy('nome')
            ->values();
    }

    private static function getBuscaEspecialidades($params)
    {
        return Especialidade::where(function ($query) use ($params) {

            if (request()->tipo_atendimento === null || request()->tipo_atendimento === 'agendamento') {

                $query->whereHas('ambulatorioJornadas', fn ($q) => $q
                    ->where('data', $params->data)
                    ->whereHas('lotacao', fn ($q) => $q
                        ->when($params->infraestrutura_id ?? null,
                            fn ($q, $id) => $q->where('infraestrutura_id', $id),
                            fn ($q) => $q->when($params->unidade_id ?? null, fn ($q, $id) => $q
                                ->whereHas('infraestrutura', fn ($q) => $q->where('unidade_id', $id))
                            )
                        )
                    )
                    ->whereHas('agendamentos', function ($q) {
                        $q->where('status_id', AgendamentoStatusEnum::AGENDADO);
                    })
                );
            }

            if (request()->tipo_atendimento === null || request()->tipo_atendimento === 'demanda_espontanea') {

                $query->orWhereExists(function ($query) use ($params) {
                    $query->select(DB::raw(1))
                        ->from('ambulatorio_demanda_espontanea')
                        ->whereColumn('ambulatorio_demanda_espontanea.especialidade_id', 'cadastro_especialidade.id')
                        ->join('ambulatorio_atendimento', 'ambulatorio_atendimento.demanda_espontanea_id', 'ambulatorio_demanda_espontanea.id')
                        ->join('painel_senha_fila', 'painel_senha_fila.id', 'ambulatorio_atendimento.fila_id')
                        ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'painel_senha_fila.centro_custo_id')
                        ->where('painel_senha_fila.emitido_em', $params->data)
                        ->where('cadastro_centro_custo.infraestrutura_id', $params->infraestrutura_id)
                        ->whereNull('ambulatorio_atendimento.finalizado_em')
                        ->whereNotNull('ambulatorio_atendimento.demanda_espontanea_id');
                });
            }
        })
        ->orderBy('nome')
        ->get(['id', 'nome']);
    }

    private static function getBuscaUsuarios($params)
    {
        return Usuario::setEagerLoads([])
            ->where(function ($query) use ($params) {

                if (request()->tipo_atendimento === null || request()->tipo_atendimento === 'agendamento') {

                    $query->whereHas('lotacoes', fn ($q) => $q
                        ->whereHas('ambulatorioJornadas', fn ($q) => $q
                            ->where('data', $params->data)
                            ->whereHas('agendamentos', function ($q) {
                                $q->where('status_id', AgendamentoStatusEnum::AGENDADO);
                            })
                            ->when($params->especialidade_id ?? null, fn ($q, $id) => $q->where('especialidade_id', $id))
                        )
                        ->when($params->infraestrutura_id ?? null,
                            fn ($q, $id) => $q->where('infraestrutura_id', $id),
                            fn ($q) => $q->when($params->unidade_id ?? null, fn ($q, $id) => $q
                                ->whereHas('infraestrutura', fn ($q) => $q->where('unidade_id', $id))
                            )
                        )
                        ->when($params->ocupacao_id ?? null, fn ($q, $id) => $q->where('ocupacao_id', $id))
                    );
                }

                if (request()->tipo_atendimento === null || request()->tipo_atendimento === 'demanda_espontanea') {

                    $query->orWhereExists(function ($query) use ($params) {
                        $query->select(DB::raw(1))
                            ->from('ambulatorio_demanda_espontanea')
                            ->whereColumn('ambulatorio_demanda_espontanea.usuario_id', 'cadastro_usuario.id')
                            ->join('ambulatorio_atendimento', 'ambulatorio_atendimento.demanda_espontanea_id', 'ambulatorio_demanda_espontanea.id')
                            ->join('painel_senha_fila', 'painel_senha_fila.id', 'ambulatorio_atendimento.fila_id')
                            ->join('cadastro_centro_custo', 'cadastro_centro_custo.id', 'painel_senha_fila.centro_custo_id')
                            ->where('painel_senha_fila.emitido_em', $params->data)
                            ->where('cadastro_centro_custo.infraestrutura_id', $params->infraestrutura_id)
                            ->whereNull('ambulatorio_atendimento.finalizado_em')
                            ->whereNotNull('ambulatorio_atendimento.demanda_espontanea_id')
                            ->when($params->especialidade_id ?? null, fn ($q, $id) => $q->where('ambulatorio_demanda_espontanea.especialidade_id', $id));
                    });
                }
            })
            ->get(['id', 'cidadao_id'])
            ->map(fn ($usuario) => [
                'id' => $usuario->id,
                'nome' => $usuario->cidadao()->setEagerLoads([])->first(['nome'])->nome,
            ])
            ->sortBy('nome')
            ->values();
    }

    public static function getEquipes(){

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
            ->select([
                'atencao_basica_parametrizacao_equipe.id AS id',
                DB::raw("
                    CONCAT(
                        CASE
                            WHEN atencao_basica_parametrizacao_area.numero_ine IS NOT NULL THEN CONCAT('INE: ', atencao_basica_parametrizacao_area.numero_ine)
                            ELSE ''
                        END,
                        CASE
                            WHEN atencao_basica_parametrizacao_area.descricao IS NOT NULL AND atencao_basica_parametrizacao_area.numero_ine IS NOT NULL THEN ' - Área: '
                            WHEN atencao_basica_parametrizacao_area.descricao IS NOT NULL THEN 'Área: '
                            ELSE ''
                        END,
                        COALESCE(atencao_basica_parametrizacao_area.descricao, ''),
                        CASE
                            WHEN atencao_basica_parametrizacao_microarea.descricao IS NOT NULL AND (atencao_basica_parametrizacao_area.numero_ine IS NOT NULL OR atencao_basica_parametrizacao_area.descricao IS NOT NULL) THEN ' - Microárea: '
                            WHEN atencao_basica_parametrizacao_microarea.descricao IS NOT NULL THEN 'Microárea: '
                            ELSE ''
                        END,
                        COALESCE(atencao_basica_parametrizacao_microarea.descricao, '')
                    ) AS descricao
                ")
            ])
            ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_id')
            ->leftJoin('atencao_basica_parametrizacao_area', 'atencao_basica_parametrizacao_area.id', 'atencao_basica_parametrizacao_equipe.area_id')
            ->leftJoin('atencao_basica_parametrizacao_microarea', 'atencao_basica_parametrizacao_microarea.id', 'atencao_basica_parametrizacao_equipe.microarea_id')
            ->join('cadastro_lotacao AS lotacao', 'lotacao.usuario_id', 'atencao_basica_parametrizacao_equipe_usuario.usuario_id')
            ->where('atencao_basica_parametrizacao_equipe_usuario.ativo', true)
            ->whereExists(fn ($q) => $q
                ->select(DB::raw(1))
                ->from('cadastro_lotacao as lotacao')
                ->whereColumn('lotacao.infraestrutura_id', 'atencao_basica_parametrizacao_equipe.infraestrutura_id')
                ->where('lotacao.infraestrutura_id', request()->infraestrutura_id)
                ->where('lotacao.usuario_id', request()->usuario_id)
                ->whereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('ambulatorio_jornada as jornada')
                    ->join(
                        'cadastro_especialidade as especialidade',
                        'especialidade.id',
                        'jornada.especialidade_id'
                    )
                    ->whereColumn('jornada.lotacao_id', 'lotacao.id')
                    ->whereNull('jornada.situacao_id')
                    ->whereDate('jornada.data', request()->data)
                    ->when(request()->paciente_id, fn ($q) => $q
                        ->where(fn ($query) => self::setCadastroWhereEspecialidadePaciente(
                            $query,
                            request()->paciente_id,
                            'especialidade'
                        ))
                    )
                    ->when(request()->paciente_nao_municipe, fn ($q) => $q
                        ->where('especialidade.permite_agendamento_nao_municipe', true)
                    )
                )
            )
            ->when(request()->usuario_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe_usuario.usuario_id', $id))
            ->when(request()->infraestrutura_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe.infraestrutura_id', $id))
            ->when(request()->ocupacao_id, fn ($q, $id) => $q->where('lotacao.ocupacao_id', $id))
            ->distinct()
            ->get();
    }

    public static function getOcupacoes()
    {
        return DB::table('sigtap.ocupacao as ocupacao')
            ->whereExists(fn ($q) => $q
                ->select(DB::raw(1))
                ->from('cadastro_lotacao as lotacao')
                ->whereColumn('lotacao.ocupacao_id', 'ocupacao.id')
                ->where('lotacao.infraestrutura_id', request()->infraestrutura_id)
                ->where('lotacao.usuario_id', request()->usuario_id)
                ->whereExists(fn ($q) => $q
                    ->select(DB::raw(1))
                    ->from('ambulatorio_jornada as jornada')
                    ->join(
                        'cadastro_especialidade as especialidade',
                        'especialidade.id',
                        'jornada.especialidade_id'
                    )
                    ->whereColumn('jornada.lotacao_id', 'lotacao.id')
                    ->whereNull('jornada.situacao_id')
                    ->whereDate('jornada.data', request()->data)
                    ->when(request()->paciente_id, fn ($q) => $q
                        ->where(fn ($query) => self::setCadastroWhereEspecialidadePaciente(
                            $query,
                            request()->paciente_id,
                            'especialidade'
                        ))
                    )
                    ->when(request()->paciente_nao_municipe, fn ($q) => $q
                        ->where('especialidade.permite_agendamento_nao_municipe', true)
                    )
                )
            )
            ->orderByRaw("CONCAT(ocupacao.codigo, ' - ', ocupacao.nome)")
            ->select(DB::raw("
                ocupacao.id,
                CONCAT(ocupacao.codigo, ' - ', ocupacao.nome) as codigo_nome
            "))
            ->get();
    }

    private static function setCadastroWhereEspecialidadePaciente($query, $pacienteId, $tableAlias = '')
    {
        if (!empty($tableAlias)) {

            $tableAlias .= '.';
        }

        $paciente = Paciente::find($pacienteId);
        $idade = $paciente->cidadao->idade;

        return $query->where(fn ($q) => $q
            ->when($idade, fn ($q) => $q
                ->where(fn ($q) => $q
                    ->whereNull("{$tableAlias}idade_minima")
                    ->orWhere("{$tableAlias}idade_minima", '<=', $idade['anos'])
                )
                ->where(fn ($q) => $q
                    ->whereNull("{$tableAlias}idade_maxima")
                    ->orWhere("{$tableAlias}idade_maxima", '>=', $idade['anos'])
                )
            )
            ->where(fn ($q) => $q
                ->whereNull("{$tableAlias}sexo_id")
                ->orWhere("{$tableAlias}sexo_id", $paciente->cidadao->sexo_id)
            )
        );
    }

    private static function getBuscaStatus($params)
    {
        return AgendamentoStatus::whereHas('agendamentos', fn ($q) =>
                self::setBuscaWhereAgendamento($q, $params)
                ->when($params->tipo_id ?? null, fn ($q, $id) => $q->where('tipo_id', $id))
                ->whereHas('jornada', fn ($q) => $q
                    ->where('data', $params->data)
                    ->whereHas('lotacao', fn ($q) => $q
                        ->when($params->infraestrutura_id ?? null,
                            fn ($q, $id) => $q->where('infraestrutura_id', $id),
                            fn ($q) => $q->when($params->unidade_id ?? null, fn ($q, $id) => $q
                                ->whereHas('infraestrutura', fn ($q) => $q->where('unidade_id', $id))
                            )
                        )
                        ->when($params->usuario_id ?? null, fn ($q, $id) => $q->where('usuario_id', $id))
                        ->when($params->ocupacao_id ?? null, fn ($q, $id) => $q->where('ocupacao_id', $id))
                    )
                    ->when($params->especialidade_id ?? null, fn ($q, $id) => $q->where('especialidade_id', $id))
                )
            )
            ->orderBy('nome')
            ->get(['id', 'nome']);
    }

    private static function setBuscaWhereAgendamento($query)
    {
        return $query->where('status_id', AgendamentoStatusEnum::AGENDADO);
    }

    public static function store()
    {
        foreach (request()->consultas as $consulta) {
            if ($consulta['status_id'] === AgendamentoStatusEnum::REALIZADO && isset($consulta['controla_protocolo_fechamento']) && $consulta['numero'] && $consulta['numero'] !== $consulta['protocolo_fechamento']) {
                throw new ProtocoloFechamentoException();
            }

            if ($consulta['status_id'] == AgendamentoStatusEnum::REALIZADO) {

                if (!empty($consulta['agendamento_id'])) {

                    $atendimento = Atendimento::where('agendamento_id', $consulta['agendamento_id'])
                        ->first() ?? new Atendimento();

                    $atendimento->fill([
                        'agendamento_id' => $consulta['agendamento_id'],
                        'paciente_id' => $consulta['paciente_id'],
                        'finalizado_em' => Carbon::now(),
                        'finalizado_lotacao_id' => self::getCurrentLotacao()->id,
                    ]);
                } else {

                    $atendimento = Atendimento::where('id', $consulta['atendimento_id'])->first();

                    $atendimento->fill([
                        'finalizado_em' => Carbon::now(),
                        'finalizado_lotacao_id' => self::getCurrentLotacao()->id,
                    ]);

                    if ($atendimento->demanda_espontanea_id) {

                        $atendimento->demandaEspontanea()->update([
                            'ocupacao_id' => $consulta['ocupacao_id'],
                            'especialidade_id' => $consulta['especialidade_id'],
                            'usuario_id' => $consulta['usuario_id'],
                        ]);
                    }
                }

                $atendimento->save();

                if ($atendimento->fila) {

                    $atendimento->fila->update(['finalizado' => true]);
                }

                $soap = new AtendimentoSoap();
                $soap->fill(self::getSoapParams($consulta, $atendimento));
                $soap->save();

                $procedimentos = array_filter($consulta['procedimentos'], function($procedimento) use ($consulta) {
                    return $procedimento['usuario_id'] === $consulta['usuario_id'];
                });

                if (isset($consulta['procedimento']) && $consulta['procedimento'] !== null) {
                    $consulta['procedimento']['quantidade'] = $consulta['quantidade'] ?? null;
                    $consulta['procedimento']['cid'] = $consulta['cid'] ?? null;

                    $procedimentos[] = $consulta['procedimento'];
                }

                $procedimentos = collect($procedimentos)->unique('codigo')->values()->toArray();


                foreach ($procedimentos as $procedimento) {

                    $atendimentoProcedimento = $soap->procedimentos()->create([
                        'atendimento_id' => $soap->atendimento_id,
                        'procedimento_id' => $procedimento['id'],
                        'quantidade' => $procedimento['quantidade'] ?? 1,
                        'cid_id' => isset($procedimento['cid']) && isset($procedimento['cid']['id']) ? $procedimento['cid']['id'] : null,
                        'automatico' => false,
                        'ocupacao_id' => $soap->atendimento->ocupacao->id,
                        'especialidade_id' => $soap->atendimento->especialidade->id,
                        'usuario_id' => $soap->atendimento->usuario->id,
                    ]);

                    $soap->procedimentosClinicos()->create([
                        'atendimento_procedimento_id' => $atendimentoProcedimento->id,
                        'observacao' => $procedimento['observacao'] ?? null,
                    ]);
                }

                if ($consulta['cid']) {

                    $data = [
                        'ciap_id' => null,
                        'cid_id' => $consulta['cid']['id'],
                        'situacao_id' => null,
                    ];

                    $soap->problemasCondicoes()->create($data);
                }

                self::storeAtendimentoIndividual($consulta, $soap);
                self::storeAtendimentoOdontologico($consulta, $soap);
            } else {

                if (!empty($consulta['agendamento_id'])) {

                    $atendimento = Atendimento::where('agendamento_id', $consulta['agendamento_id'])->first();
                } else {

                    $atendimento = Atendimento::where('id', $consulta['atendimento_id'])->first();
                }

                if ($atendimento) {

                    $atendimento->update([
                        'finalizado_em' => Carbon::now(),
                        'finalizado_lotacao_id' => self::getCurrentLotacao()->id,
                    ]);

                    if ($atendimento->fila) {

                        $atendimento->fila->update(['finalizado' => true]);
                    }
                }
            }

            if (!empty($consulta['agendamento_id'])) {

                $agendamentoStatus = Agendamento::findOrFail($consulta['agendamento_id']);

                if ($agendamentoStatus) {

                    $params = [
                        'status_id' => $consulta['status_id'],
                    ];

                    $agendamentoStatus->update($params);
                }

                if (!is_null($consulta['regulacao_solicitacao_id'])) {

                    $statusTipoId = null;

                    if ($consulta['status_id'] === AgendamentoStatusEnum::REALIZADO) {

                        $statusTipoId = RegulacaoStatusTipoEnum::REALIZADO;
                    } else if ($consulta['status_id'] === AgendamentoStatusEnum::FALTA_DO_PACIENTE) {

                        $statusTipoId = RegulacaoStatusTipoEnum::FALTA;
                    }

                    if (!is_null($statusTipoId)) {

                        RegulacaoSolicitacaoService::updateStatus($consulta['regulacao_solicitacao_id'], $statusTipoId);
                    }
                }
            }
        }

        self::procedimentosUsuarioCompartilhado(request()->consultas);
    }

    private static function storeAtendimentoIndividual($consulta, $soap) {

        if (array_key_exists('atendimento_individual', $consulta)) {

            if (!self::criaFicha($consulta['infraestrutura_id'], $consulta['ocupacao_id'], 'atendimento-individual')) {

                return;
            }

            $fichaAtendimentoIndividual = $consulta['atendimento_individual'];
            $fichaAtendimentoIndividual['soap_id'] = $soap->id;
            $fichaAtendimentoIndividual['paciente_id'] = $soap->atendimento->paciente->id;
            $fichaAtendimentoIndividual['cadastro']['usuario_id'] = $fichaAtendimentoIndividual['cadastro']['usuario']['id'];
            $fichaAtendimentoIndividual['cadastro']['usuario_auxiliar_id'] = $fichaAtendimentoIndividual['cadastro']['usuario_auxiliar']['id'] ?? null;

            try {

                AtendimentoIndividualService::saveStore($fichaAtendimentoIndividual);
            }
            catch (Exception $e) {

                throw new NaoPodeCriarFichaAtencaoBasicaException();
            }
        }
    }

    private static function storeAtendimentoOdontologico($consulta, $soap) {

        if (array_key_exists('atendimento_odontologico', $consulta)) {

            if (!self::criaFicha($consulta['infraestrutura_id'], $consulta['ocupacao_id'], 'atendimento-odontologico')) {

                return;
            }

            $fichaAtendimentoOdontologico = $consulta['atendimento_odontologico'];
            $fichaAtendimentoOdontologico['soap_id'] = $soap->id;
            $fichaAtendimentoOdontologico['paciente_id'] = $soap->atendimento->paciente->id;
            $fichaAtendimentoOdontologico['cadastro']['usuario_id'] = $fichaAtendimentoOdontologico['cadastro']['usuario']['id'];
            $fichaAtendimentoOdontologico['cadastro']['usuario_auxiliar_id'] = $fichaAtendimentoOdontologico['cadastro']['usuario_auxiliar']['id'];

            foreach ($consulta['procedimentos_quantidade'] as $procedimentoQuantidade) {

                $fichaAtendimentoOdontologico['procedimentos'][] = $procedimentoQuantidade;
            }

            try {

                AtendimentoOdontologicoService::saveStore($fichaAtendimentoOdontologico);
            }
            catch (Exception $e) {

                throw new NaoPodeCriarFichaAtencaoBasicaException();
            }
        }
    }

    private static function criaFicha($infraestruturaId, $ocupacaoId, $funcionalidadeIdentificador)
    {
        return ParametrizacaoInfraestruturaOcupacao::whereHas('parametrizacaoInfraestrutura', fn ($q) => $q
                ->where('infraestrutura_id', $infraestruturaId)
            )
            ->where('ocupacao_id', $ocupacaoId)
            ->whereHas('fichasAtb', fn ($q) => $q
                ->where('funcionalidade_id', self::getAtencaoBasicaFuncionalidadeId($funcionalidadeIdentificador))
            )
            ->exists();
    }

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

    private static function procedimentosUsuarioCompartilhado($consultas) {

        $atendimentos = [];

        foreach ($consultas as $consulta) {

            if ($consulta['status_id'] == AgendamentoStatusEnum::REALIZADO) {

                $pacienteId = $consulta['paciente_id'];
                $unidadeId = $consulta['unidade_id'];
                $infraestruturaId = $consulta['infraestrutura_id'];
                $localAtendimentoId = $consulta['atencao_basica_local_atendimento_id'];
                $turnoId = $consulta['turno_id'];
                $data = $consulta['data'];
                $usuarioResponsavel = $consulta['usuario_id'];

                $procedimentos = array_filter($consulta['procedimentos'], function($procedimento) use ($usuarioResponsavel) {
                    return $procedimento['usuario_id'] !== $usuarioResponsavel;
                });

                foreach ($procedimentos as $procedimento) {

                    if (!$procedimento['equipe_id']) {
                        continue;
                    }

                    $usuarioId = $procedimento['usuario_id'];
                    $ocupacaoId = $procedimento['ocupacao_id'];
                    $equipeId = $procedimento['equipe_id'];
                    $procedimentoId = $procedimento['id'];
                    $quantidade = $procedimento['quantidade'];
                    $index = self::getIndexProcedimento($atendimentos, $pacienteId, $usuarioId, $ocupacaoId,
                        $localAtendimentoId, $equipeId, $unidadeId, $infraestruturaId);

                    if ($index !== null) {

                        $item = array_search(
                            $procedimentoId,
                            array_column($atendimentos[$index]['procedimentos'], 'id')
                        );

                        if ($item !== false) {

                            $atendimentos[$index]['procedimentos'][$item]['quantidade'] += $quantidade;
                        } else {

                            $atendimentos[$index]['procedimentos'][] = [
                                'id' => $procedimentoId,
                                'quantidade' => $quantidade,
                            ];
                        }
                    } else {

                        $atendimentos[] = [
                            'id' => null,
                            'paciente_id' => $pacienteId,
                            'local_atendimento_id' => $localAtendimentoId,
                            'usuario_id' => $usuarioId,
                            'ocupacao_id' => $ocupacaoId,
                            'equipe_id' => $equipeId,
                            'data_usuario_responsavel' => $data,
                            'infraestrutura_id' => $infraestruturaId,
                            'unidade_id' => $unidadeId,
                            'afericao_pa' => null,
                            'altura' => null,
                            'curativo' => null,
                            'exame_laboratorial' => null,
                            'glicemia' => null,
                            'teste_rapido' => null,
                            'procedimento_pequena_cirurgia' => null,
                            'administracao_medicamento' => null,
                            'peso' => null,
                            'temperatura' => null,
                            'microarea_id' => null,
                            'escuta_inicial' => null,
                            'turno_id' => $turnoId,
                            'procedimentos' => [[
                                'id' => $procedimentoId,
                                'quantidade' => $quantidade,
                            ]],
                        ];
                    }
                }
            }
        }

        self::storeProcedimentos($atendimentos);
    }

    private static function storeProcedimentos($procedimentos) {

        $atendimentos = [];
        $index = null;

        foreach ($procedimentos as $procedimento) {

            $usuarioId = $procedimento['usuario_id'];
            $ocupacaoId = $procedimento['ocupacao_id'];
            $equipeId = $procedimento['equipe_id'];

            if (isset($atendimentos) && !empty($atendimentos)) {
                $index = self::getIndexAtendimento($atendimentos, $usuarioId, $ocupacaoId, $equipeId);
            }

            if ($index !== null) {

                $atendimentos[$index]['atendimentos'][] =  $procedimento;
            } else {

                $atendimentos[] = [
                    'id' => null,
                    'origem' => 'ambulatorio',
                    'cadastro' => [
                        'data_usuario_responsavel' => $procedimento['data_usuario_responsavel'],
                        'equipe_id' => $procedimento['equipe_id'],
                        'infraestrutura_id' => $procedimento['infraestrutura_id'],
                        'ocupacao_id' => $procedimento['ocupacao_id'],
                        'unidade_id' => $procedimento['unidade_id'],
                        'usuario_id' => $procedimento['usuario_id'],
                    ],
                    'atendimentos' => [$procedimento],
                    'procedimento_consolidado' => [
                        'afericao_pa' => null,
                        'altura' => null,
                        'curativo' => null,
                        'exame_laboratorial' => null,
                        'glicemia_capilar' => null,
                        'peso' => null,
                        'temperatura' => null,
                    ]
                ];
            }

            foreach ($atendimentos as $atendimento) {

                try {

                    ProcedimentoService::saveStore($atendimento);
                }
                catch (Exception $e) {

                    throw new NaoPodeCriarFichaAtencaoBasicaException();
                }
            }
        }
    }

    private static function getIndexAtendimento($atendimentos, $usuarioId, $ocupacaoId, $equipeId) {

        $index = null;

        foreach ($atendimentos as $i => $item) {

            if ($item['cadastro']['usuario_id'] == $usuarioId
                && $item['cadastro']['ocupacao_id'] == $ocupacaoId
                && $item['cadastro']['equipe_id'] == $equipeId
            ) {

                $index = $i;
                break;
            }
        }

        return $index;
    }

    private static function getIndexProcedimento($procedimentos, $pacienteId, $usuarioId, $ocupacaoId,
        $localAtendimentoId, $equipeId, $unidadeId, $infraestruturaId) {

        $index = null;

        foreach ($procedimentos as $i => $item) {

            if ($item['paciente_id'] == $pacienteId
                && $item['local_atendimento_id'] == $localAtendimentoId
                && $item['usuario_id'] == $usuarioId
                && $item['ocupacao_id'] == $ocupacaoId
                && $item['equipe_id'] == $equipeId
                && $item['unidade_id'] == $unidadeId
                && $item['infraestrutura_id'] == $infraestruturaId
            ) {

                $index = $i;
                break;
            }
        }

        return $index;
    }

    private static function getSoapParams($agendamento, $atendimento)
    {
        $params = [
            'atendimento_id' => $atendimento->id,
            'equipe_id' => null,
            'atencao_basica_local_atendimento_id' => $agendamento['atencao_basica_local_atendimento_id'],
            'turno_id' => $agendamento['turno_id'],
            'paciente_liberado' => true
        ];

        return $params;
    }
}