<?php

namespace App\Services\AtencaoBasica\AtendimentoIndividual;

use App\Enums\Ambulatorio\ProblemaCondicaoSituacao as AmbulatorioProblemaCondicaoSituacao;
use App\Enums\AtencaoBasica\AtendimentoIndividual\CondicaoAvaliada as EnumsCondicaoAvaliada;
use App\Enums\AtencaoBasica\AtendimentoIndividual\Conduta as AtendimentoIndividualConduta;
use App\Enums\AtencaoBasica\AtendimentoIndividual\ExameSolicitadoAvaliado as EnumsExameSolicitadoAvaliado;
use App\Enums\AtencaoBasica\AtendimentoIndividual\LocalAtendimento as EnumsLocalAtendimento;
use App\Enums\AtencaoBasica\AtendimentoIndividual\ModalidadeAtencaoDomiciliar as EnumsModalidadeAtencaoDomiciliar;
use App\Enums\AtencaoBasica\AtendimentoIndividual\Rastreamento as EnumsRastreamento;
use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento as EnumsTipoAtendimento;
use App\Enums\AtencaoBasica\Parametrizacao\Permissao;
use App\Enums\Cadastro\SujeitoAtencao\FatorRisco as FatorRiscoEnum;
use App\Enums\Cadastro\SujeitoAtencao\Sexo;
use App\Enums\Geral\Ciap as CiapEnum;
use App\Enums\Sigtap\Cid as CidEnum;
use App\Enums\Sigtap\Procedimento as SigtapProcedimento;
use App\Exceptions\AtencaoBasica\CondicaoAvaliadaException;
use App\Exceptions\AtencaoBasica\ExameSolicitadoAvaliadoException;
use App\Exceptions\AtencaoBasica\RastreamentoException;
use App\Models\Ambulatorio\GlicemiaCapilarMomentoColeta;
use App\Models\Ambulatorio\ProblemaCondicaoSituacao;
use App\Models\AtencaoBasica\AtendimentoIndividual\AleitamentoMaterno;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividual;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualExameSolicitadoAvaliado;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualIvcf;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualOutroExame;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualProblemaCondicao;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualProcedimento;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualTriagemNeonatal;
use App\Models\AtencaoBasica\AtendimentoIndividual\CondicaoAvaliada;
use App\Models\AtencaoBasica\AtendimentoIndividual\Conduta;
use App\Models\AtencaoBasica\AtendimentoIndividual\DoencaTransmissivel;
use App\Models\AtencaoBasica\AtendimentoIndividual\Encaminhamento;
use App\Models\AtencaoBasica\AtendimentoIndividual\EscalaCoelho;
use App\Models\AtencaoBasica\AtendimentoIndividual\ExameSolicitadoAvaliado;
use App\Models\AtencaoBasica\AtendimentoIndividual\ModalidadeAtencaoDomiciliar;
use App\Models\AtencaoBasica\AtendimentoIndividual\Nasf;
use App\Models\AtencaoBasica\AtendimentoIndividual\RacionalidadeSaude;
use App\Models\AtencaoBasica\AtendimentoIndividual\Rastreamento;
use App\Models\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
use App\Models\AtencaoBasica\AtendimentoIndividual\TriagemNeonatal;
use App\Models\AtencaoBasica\CadastroIndividual\CadastroIndividual;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\LocalAtendimento;
use App\Models\AtencaoBasica\Parametrizacao\Equipe;
use App\Models\AtencaoBasica\Parametrizacao\OutrosPermissaoOcupacao;
use App\Models\AtencaoBasica\Procedimento\Procedimento as ModelAtencaoBasicaProcedimento;
use App\Models\AtencaoBasica\Procedimento\ProcedimentoAtendimento;
use App\Models\AtencaoBasica\Procedimento\ProcedimentoAtendimentoProcedimento;
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\Parametrizacao\Exame\Exame;
use App\Models\Sigtap\Ocupacao;
use App\Models\Sigtap\Procedimento;
use App\Services\AtencaoBasica\Procedimento\ProcedimentoService;
use App\Services\Integracao\CnsService;
use App\Services\Service;
use App\Utils\MaskUtil;
use Carbon\Carbon;
use DateTime;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;

class AtendimentoIndividualService extends Service
{
    public const CIAPS_GRAVIDEZ_NORMAL = [
        CiapEnum::GRAVIDEZ,
    ];

    public const CIDS_GRAVIDEZ_NORMAL = [
        CidEnum::SUPERVISAO_DE_GRAVIDEZ_NORMAL,
        CidEnum::SUPERVISAO_DE_PRIMEIRA_GRAVIDEZ_NORMAL,
        CidEnum::SUPERVISAO_DE_OUTRA_GRAVIDEZ_NORMAL,
        CidEnum::SUPERVISAO_DE_GRAVIDEZ_NORMAL_NAO_ESPECIFICADA,
    ];

    public static function index()
    {
        return [];
    }

    public static function getAtendimentos()
    {

        $paciente = Paciente::findOrFail(request()->id);

        return [
            'additionals' => [
                'permissoes_atualizacao_cadastro_paciente' => self::getPermissoesAtualizacaoCadastroPaciente(),
            ],
            'atendimentos' => AtendimentoIndividual::where('paciente_id', request()->id)
                ->get()
                ->map(function ($query) {
                    return [
                        'id' => $query->id,
                        'data' => $query->data_usuario_responsavel,
                        'turno' => $query->turno->nome ?? null,
                        'local_atendimento' => $query->localAtendimento->descricao ?? null,
                        'profissional' => $query->usuario->cidadao->nome ?? null,
                        'data_exportacao' => $query->data_hora_exportacao
                            ? (new Carbon($query->data_hora_exportacao))->format('d/m/Y') . ' às '
                                . (new Carbon($query->data_hora_exportacao))->format('H:i')
                            : null,
                        'profissional_exportacao' => $query->usuarioExportacao->cidadao->nome ?? null,
                    ];
                }),
            'cidadao' => [
                'paciente_id' => $paciente->id ?? null,
                'nome' => $paciente->cidadao->nome ?? null,
                'nome_social' => $paciente->cidadao->nome_social ?? null,
                'sexo' => $paciente->cidadao->sexo->descricao ?? null,
                'cns' => $paciente ? MaskUtil::getCnsMasked($paciente->cidadao->cns) : null,
                'data_nascimento' => $paciente->cidadao->data_nascimento->format('Y-m-d') ?? null,
                'idade' => [
                    'anos' => $paciente->cidadao->idade['anos'],
                    'meses' => $paciente->cidadao->idade['meses'],
                    'dias' => $paciente->cidadao->idade['dias'],
                ],
                'prontuario' => $paciente->prontuario,
                'subclassificacao_id' => $paciente->subclassificacao_id,
                'sexo' => $paciente->cidadao->sexo,
                'telefones' => $paciente->cidadao->telefones->map(fn ($t) => MaskUtil::getPhoneMasked($t->numero))->all(),
                'cpf' => $paciente->cidadao->cpf ? MaskUtil::getCpfMasked($paciente->cidadao->cpf) : null,
                'nome_mae' => $paciente->cidadao->nome_mae ?? null,
                'classificacao_id' => $paciente->classificacao_id,
                'cidadao_id' => $paciente->cidadao_id,
            ],
        ];
    }

    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')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_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')
            ->where('atencao_basica_parametrizacao_equipe_usuario.ativo', 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))
            ->get();
    }

    public static function getUnidades(){

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
            ->select([
                'cadastro_unidade.id AS id',
                DB::raw("CONCAT(TRIM(cadastro_unidade.cnes), ' - ',  cadastro_unidade.nome_fantasia ) AS nome_fantasia"),
            ])
            ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_id')
            ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_id')
            ->where('atencao_basica_parametrizacao_equipe_usuario.ativo', true)
            ->when(request()->usuario_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe_usuario.usuario_id', $id))
            ->distinct()
            ->orderBy('cadastro_unidade.cnes')
            ->get();
    }

    public static function getInfraestruturas(){

        return DB::table('atencao_basica_parametrizacao_equipe_usuario')
        ->select([
            'cadastro_infraestrutura.id AS id',
            DB::raw('COALESCE(cadastro_infraestrutura.nome, cadastro_unidade.nome_fantasia) AS nome'),
        ])
        ->join('atencao_basica_parametrizacao_equipe', 'atencao_basica_parametrizacao_equipe.id', 'atencao_basica_parametrizacao_equipe_usuario.equipe_id')
        ->join('cadastro_infraestrutura', 'cadastro_infraestrutura.id', 'atencao_basica_parametrizacao_equipe.infraestrutura_id')
        ->join('cadastro_unidade', 'cadastro_unidade.id', 'atencao_basica_parametrizacao_equipe.unidade_id')
        ->where('atencao_basica_parametrizacao_equipe_usuario.ativo', true)
        ->when(request()->usuario_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe_usuario.usuario_id', $id))
        ->when(request()->unidade_id, fn ($q, $id) => $q->where('atencao_basica_parametrizacao_equipe.unidade_id', $id))
        ->distinct()
        ->orderBy('nome')
        ->get();
    }

    public static function getOcupacoes()
    {
        $usuario = Usuario::findOrFail(request()->usuario_id);
        $permissao = OutrosPermissaoOcupacao::where('permissao_id', Permissao::ATENDIMENTO_INDIVIDUAL)->get();
        $codigos = $permissao->pluck('ocupacao');

        return $usuario->lotacoes
            ->filter(function ($lotacao) use ($codigos) {
                return $lotacao->infraestrutura->id == request()->infraestrutura_id &&
                    $codigos->contains($lotacao->ocupacao->codigo);
            })
            ->pluck('ocupacao');
    }

    public static function getOcupacoesAuxiliar()
    {
        $usuario = Usuario::findOrFail(request()->usuario_id);

        return $usuario->lotacoes
            ->filter(function ($lotacao) {
                return $lotacao->infraestrutura->id == request()->infraestrutura_id;
            })
            ->pluck('ocupacao');
    }

    private static function getFormData($paciente, $dataAtendimento, $atendimento)
    {

        $gestanteAtendimentos = AtendimentoIndividual::where('paciente_id', $paciente->id)
            ->where('data_usuario_responsavel', '<=', $dataAtendimento)
            ->whereNotNull('data_ultima_menstruacao');

        if ($atendimento !== null) {
            $gestanteAtendimentos->where('id', '!=', $atendimento->id);
        }

        return [
            '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(),
            'tipo_atendimento' => TipoAtendimento::whereNotIn('id', [
                    EnumsTipoAtendimento::ATENDIMENTO_PROGRAMADO,
                    EnumsTipoAtendimento::ATENDIMENTO_NAO_PROGRAMADO,
                    EnumsTipoAtendimento::VISITA_DOMICILIAR_POS_OBITO,
                ])
                ->orderBy('descricao')
                ->get(),
            'atencao_domiciliar' => ModalidadeAtencaoDomiciliar::whereNotIn('id', [
                    EnumsModalidadeAtencaoDomiciliar::INELEGIVEL
                ])
                ->orderBy('descricao')
                ->get(),
            'condicao_avaliada' => CondicaoAvaliada::orderBy('descricao')->get(),
            'doenca_transmissivel' => DoencaTransmissivel::orderBy('descricao')->get(),
            'rastreamento' => Rastreamento::orderBy('descricao')->get(),
            'exame_solicitado_avaliado' => ExameSolicitadoAvaliado::orderBy('descricao')->get(),
            'triagem_neonatal' => TriagemNeonatal::orderBy('descricao')->get(),
            'nasf' => Nasf::orderBy('descricao')->get(),
            'conduta' => Conduta::whereNotIn('id', [AtendimentoIndividualConduta::AGENDAMENTO_PARA_NASF])->orderBy('descricao')->get(),
            'encaminhamento' => Encaminhamento::orderBy('descricao')->get(),
            'aleitamento_materno' => AleitamentoMaterno::orderBy('descricao')->get(),
            'racionalidade_saude' => RacionalidadeSaude::orderBy('descricao')->get(),
            'escala_coelho' => EscalaCoelho::orderBy('id')->get(),
            'procedimentos' => Procedimento::whereIn('codigo', [
                    SigtapProcedimento::MEDICAO_PESO,
                    SigtapProcedimento::MEDICAO_ALTURA,
                    SigtapProcedimento::AFERICAO_TEMPERATURA,
                    SigtapProcedimento::AFERICAO_PRESSAO_ARTERIAL,
                    SigtapProcedimento::AVALIACAO_ANTROPOMETRICA,
                ])
                ->where('competencia_id', function ($query) {
                    $query->select('sigtap.competencia.id')
                        ->from('sigtap.competencia')
                        ->orderByDesc('sigtap.competencia.valor')
                        ->limit(1);
                })
                ->groupBy('codigo')
                ->get(),
            'gestante' =>  $gestanteAtendimentos->get()
                ->map(function ($atendimento) {
                    return [
                        'data' => (new Carbon($atendimento->data_usuario_responsavel))->format('d/m/Y'),
                        'dum' => (new Carbon($atendimento->data_ultima_menstruacao))->format('d/m/Y'),
                        'idade_gestacional' => $atendimento->idade_gestacional_semanas . ' semana(s) e '
                            . $atendimento->idade_gestacional_dias . ' dia(s)',
                        'usuario' => $atendimento->usuario->cidadao->nome ?? null,
                        'unidade' => $atendimento->equipe->unidade->nome_fantasia ?? null,
                        'ocupacao' => $atendimento->usuarioOcupacao->codigo_nome ?? null,
                    ];
                }),
            'momentos_coleta' => GlicemiaCapilarMomentoColeta::orderBy('id')->get(['id', 'nome']),
            'problema_condicao_situacoes' => ProblemaCondicaoSituacao::orderBy('nome')->get(['id', 'nome']),
            'problemas_condicoes_paciente' => self::getProblemasCondicoesAtivosOuLatentes($paciente, $atendimento)
        ];
    }

    private static function getProblemasCondicoesAtivosOuLatentes($paciente, $atendimento = null)
    {
        return AtendimentoIndividualProblemaCondicao::whereIn('situacao_id', [
                AmbulatorioProblemaCondicaoSituacao::ATIVO,
                AmbulatorioProblemaCondicaoSituacao::LATENTE,
            ])
            ->whereHas('atendimentoIndividual', fn ($q) => $q
                ->where('paciente_id', $paciente->id)
                ->when($atendimento, fn ($q) => $q
                    ->where('id', '<>', $atendimento->id)
                    ->where('data_usuario_responsavel', '<=', $atendimento->data_usuario_responsavel)
                )
            )
            ->whereDoesntHave('problemaCondicaoPosterior')
            ->get()
            ->map(fn ($problemaCondicao) => [
                'id' => $problemaCondicao->id,
                'ciap' => [
                    'id' => $problemaCondicao->ciap_id,
                    'codigo' => $problemaCondicao->ciap->codigo ?? null,
                    'descricao' => $problemaCondicao->ciap->descricao ?? null,
                ],
                'cid' => [
                    'id' => $problemaCondicao->cid_id,
                    'codigo' => $problemaCondicao->cid->codigo ?? null,
                    'nome' => $problemaCondicao->cid->nome ?? null,
                ],
                'situacao_id' => $problemaCondicao->situacao_id,
                'situacao_nome' => $problemaCondicao->situacao->nome,
                'inicio' => is_null($problemaCondicao->inicio) ? null : $problemaCondicao->inicio->format('d/m/Y'),
                'fim' => is_null($problemaCondicao->fim) ? null : $problemaCondicao->fim->format('d/m/Y'),
                'observacao' => $problemaCondicao->observacao,
            ]);
    }

    private static function getModelData($atendimento = null, $paciente = null)
    {

        $cadastroIndividual = $paciente->cadastroIndividual ?? null;

        if ($atendimento) {
            $ivcf = AtendimentoIndividualIvcf::where('atendimento_individual_id', $atendimento->id)->first();
        } else {
            $ivcf = null;
        }

        return [
            'cadastro' => [
                'usuario' => [
                    'id' => $atendimento->usuario->id ?? null,
                    'cidadao_nome' => $atendimento->usuario->cidadao->nome ?? null,
                ],
                'unidade_id' => $atendimento->equipe->unidade_id ?? null,
                'infraestrutura_id' => $atendimento->equipe->infraestrutura_id ?? null,
                'equipe_id' => $atendimento->equipe_id ?? null,
                'ocupacao_id' => $atendimento->usuario_ocupacao_id ?? null,
                'data_usuario_responsavel' => $atendimento->data_usuario_responsavel ?? Carbon::now()->format('Y-m-d'),
                'usuario_auxiliar' => [
                    'id' => $atendimento->usuarioAuxiliar->id ?? null,
                    'cidadao_nome' => $atendimento->usuarioAuxiliar->cidadao->nome ?? null,
                ],
                'unidade_auxiliar_id' => $atendimento->usuarioAuxiliarEquipe->unidade_id ?? null,
                'infraestrutura_auxiliar_id' => $atendimento->usuarioAuxiliarEquipe->infraestrutura_id ?? null,
                'equipe_auxiliar_id' => $atendimento->usuario_auxiliar_equipe_id ?? null,
                'ocupacao_auxiliar_id' => $atendimento->usuario_auxiliar_ocupacao_id ?? null,
            ],
            'cidadao' => [
                'paciente_id' => $paciente->id ?? null,
                'nome' => $paciente->cidadao->nome ?? null,
                'nome_social' => $paciente->cidadao->nome_social ?? null,
                'escala_coelho' => $paciente->cidadao->domicilio->cadastroDomiciliar->escalaCoelho->descricao ?? 'NÃO INFORMADO',
                'sexo_id' => $paciente->cidadao->sexo_id ?? null,
                'sexo' => $paciente->cidadao->sexo->descricao ?? null,
                'cns' => $paciente ? MaskUtil::getCnsMasked($paciente->cidadao->cns) : null,
                'cpf' => $paciente ? MaskUtil::getCpfMasked($paciente->cidadao->cpf) : null,
                'data_nascimento' => $paciente->cidadao->data_nascimento->format('Y-m-d') ?? null,
                'idade' => $paciente->cidadao->data_nascimento
                    ? "{$paciente->cidadao->idade['anos']} ano(s), "
                        . "{$paciente->cidadao->idade['meses']} mês(es) e "
                        . "{$paciente->cidadao->idade['dias']} dia(s) "
                    : 'NÃO INFORMADA',
                'classificacao_id' => $paciente->classificacao_id,
                'cidadao_id' => $paciente->cidadao_id,
                'idade_anos' => $paciente->cidadao->idade['anos'] ?? null,
            ],
            'condicao' => [
                'gestante' => $cadastroIndividual ? $paciente->cadastroIndividual->gestante : false,
                'fumante' => $cadastroIndividual ? $paciente->cadastroIndividual->fumante : false,
                'usa_alcool' => $cadastroIndividual ? $paciente->cadastroIndividual->usa_alcool : false,
                'outras_drogas' => $cadastroIndividual ? $paciente->cadastroIndividual->outras_drogas : false,
                'hipertensao' => $cadastroIndividual ? $paciente->cadastroIndividual->hipertensao : false,
                'diabetes' => $cadastroIndividual ? $paciente->cadastroIndividual->diabetes : false,
                'cadastro_individual_id' => $cadastroIndividual ? $cadastroIndividual->id : null,
            ],
            'atendimento' => [
                'id' => $atendimento ? $atendimento->id : null,
                'turno_id' => $atendimento ? $atendimento->turno_id : null,
                'local_atendimento_id' => $atendimento ? $atendimento->local_atendimento_id : null,
                'tipo_atendimento_id' => $atendimento ? $atendimento->tipo_atendimento_id : null,
                'perimetro_cefalico' => $atendimento ? $atendimento->perimetro_cefalico : null,
                'glicemia' => $atendimento ? $atendimento->glicemia : null,
                'momento_coleta_id' => $atendimento ? $atendimento->momento_coleta_id : null,
                'saturacao_o2' => $atendimento ? $atendimento->saturacao_o2 : null,
                'circunferencia_abdominal' => $atendimento ? $atendimento->circunferencia_abdominal : null,
                'perimetro_panturrilha' => $atendimento ? $atendimento->perimetro_panturrilha : null,
                'frequencia_cardiaca' => $atendimento ? $atendimento->frequencia_cardiaca : null,
                'frequencia_respiratoria' => $atendimento ? $atendimento->frequencia_respiratoria : null,
                'pressao_arterial' => $atendimento ? $atendimento->pressao_arterial : null,
                'peso' => $atendimento ? $atendimento->peso : null,
                'altura' => $atendimento ? $atendimento->altura : null,
                'temperatura' => $atendimento ? $atendimento->temperatura : null,
                'vacinacao' => $atendimento ? $atendimento->vacinacao : null,
                'modalidade_atencao_domiciliar_id' => $atendimento ? $atendimento->modalidade_atencao_domiciliar_id : null,
                'aleitamento_materno_id' => $atendimento ? $atendimento->aleitamento_materno_id : null,
                'racionalidade_saude_id' => $atendimento ? $atendimento->racionalidade_saude_id : null,
                'condicao_avaliada' =>  $atendimento ? $atendimento->condicaoAvaliada->pluck('id') : [],
                'doenca_transmissivel' => $atendimento ? $atendimento->doencaTransmissivel->pluck('id') : [],
                'rastreamento' => $atendimento ? $atendimento->rastreamento->pluck('id') : [],
                'problemas_condicoes' => $atendimento ? $atendimento->problemasCondicoes->map(fn ($problemaCondicao) => [
                    'problema_condicao_anterior_id' => null,
                    'id' => $problemaCondicao->id,
                    'automatico' => $problemaCondicao->automatico,
                    'ciap' => $problemaCondicao->ciap ? [
                        'id' => $problemaCondicao->ciap->id,
                        'codigo' => $problemaCondicao->ciap->codigo,
                        'descricao' => $problemaCondicao->ciap->descricao,
                    ] : null,
                    'cid' => $problemaCondicao->cid ? [
                        'id' => $problemaCondicao->cid->id,
                        'codigo' => $problemaCondicao->cid->codigo,
                        'nome' => $problemaCondicao->cid->nome,
                    ] : null,
                    'incluir_lista_paciente' => !is_null($problemaCondicao->situacao_id),
                    'situacao_id' => $problemaCondicao->situacao_id,
                    'situacao_nome' => $problemaCondicao->situacao->nome ?? null,
                    'inicio' => $problemaCondicao->inicio ? [
                        'data' => $problemaCondicao->inicio->format('d/m/Y'),
                        'ano' => null,
                        'mes' => null,
                    ] : null,
                    'fim' => $problemaCondicao->fim ? [
                        'data' => $problemaCondicao->fim->format('d/m/Y'),
                        'ano' => null,
                        'mes' => null,
                    ] : null,
                    'observacao' => $problemaCondicao->observacao,
                    'has_continuidade' => $problemaCondicao->problemaCondicaoPosterior()->exists()
                ]) : collect(),
                'exame_solicitado_avaliado' => $atendimento ? AtendimentoIndividualExameSolicitadoAvaliado::where('atendimento_individual_id', $atendimento->id)
                    ->get()
                    ->map(function ($query) {
                        $results = [];

                        if ($query->solicitado) {
                            $results[] = 's_' . $query->exame_solicitado_avaliado_id;
                        }

                        if ($query->avaliado) {
                            $results[] = 'a_' . $query->exame_solicitado_avaliado_id;
                        }

                        return $results;
                    })
                    ->flatten()
                    ->values() : [],
                'triagem_neonatal' => $atendimento ? AtendimentoIndividualTriagemNeonatal::where('atendimento_individual_id', $atendimento->id)
                    ->get()
                    ->map(function ($query) {
                        $results = [];

                        if ($query->solicitado) {
                            $results[] = 's_' . $query->triagem_neonatal_id;
                        }

                        if ($query->avaliado) {
                            $results[] = 'a_' . $query->triagem_neonatal_id;
                        }

                        return $results;
                    })
                    ->flatten()
                    ->values() : [],
                'outros_exames' => $atendimento ? AtendimentoIndividualOutroExame::where('atendimento_individual_id', $atendimento->id)
                    ->get()
                    ->map(function ($query) {
                        return [
                            'id' => $query->id,
                            'avaliado' => $query->avaliado,
                            'exame_id' => $query->exame_id ?? null,
                            'solicitado' => $query->solicitado ?? null,
                            'exame_nome' => $query->exame->nome ?? null,
                            'codigo' => $query->exame->codigo ?? null,
                        ];
                    })
                    ->sortBy('exame_nome')
                    ->values() : [],
                'observacao' => $atendimento ? $atendimento->observacao : null,
                'nasf' => $atendimento ? $atendimento->nasf->pluck('id') : [],
                'conduta' => $atendimento ? $atendimento->conduta->pluck('id') : [],
                'encaminhamento' => $atendimento ? $atendimento->encaminhamento->pluck('id') : [],
                'dum' => $atendimento ? $atendimento->data_ultima_menstruacao : null,
                'idade_gestacional_semanas' => $atendimento ? $atendimento->idade_gestacional_semanas : null,
                'idade_gestacional_dias' => $atendimento ? $atendimento->idade_gestacional_dias : null,
                'data_possivel_parto' => $atendimento ? $atendimento->data_possivel_parto : null,
                'gravidez_planejada' => $atendimento ? $atendimento->gravidez_planejada : null,
                'gestacao_previa' => $atendimento ? $atendimento->gestacao_previa : null,
                'parto' => $atendimento ? $atendimento->parto : null,
                'ivcf' => [
                    'deseja_preencher' => $ivcf ? true : false,
                    'estado_saude_geral' => $ivcf->estado_saude_geral ?? null,
                    'limitacao_compras' => $ivcf->limitacao_compras ?? null,
                    'limitacao_gestao_financeira' => $ivcf->limitacao_gestao_financeira ?? null,
                    'limitacao_tarefas_domesticas' => $ivcf->limitacao_tarefas_domesticas ?? null,
                    'banho_independencia' => $ivcf->banho_independencia ?? null,
                    'relato_esquecimento_por_terceiros' => $ivcf->relato_esquecimento_por_terceiros ?? null,
                    'esquecimento_piorando' => $ivcf->esquecimento_piorando ?? null,
                    'esquecimento_impacta_atividades' => $ivcf->esquecimento_impacta_atividades ?? null,
                    'humor_tristeza_desanimo' => $ivcf->humor_tristeza_desanimo ?? null,
                    'perda_interesse_atividades' => $ivcf->perda_interesse_atividades ?? null,
                    'limitacao_elevar_bracos' => $ivcf->limitacao_elevar_bracos ?? null,
                    'limitacao_motricidade_fina' => $ivcf->limitacao_motricidade_fina ?? null,
                    'perda_peso_nao_intencional' => $ivcf->perda_peso_nao_intencional ?? null,
                    'imc_abaixo_22' => $ivcf->imc_abaixo_22 ?? null,
                    'panturrilha_abaixo_31' => $ivcf->panturrilha_abaixo_31 ?? null,
                    'marcha_lenta_4m_maior_5s' => $ivcf->marcha_lenta_4m_maior_5s ?? null,
                    'dificuldade_caminhar_impacto_atividades' => $ivcf->dificuldade_caminhar_impacto_atividades ?? null,
                    'quedas_recorrentes' => $ivcf->quedas_recorrentes ?? null,
                    'incontinencia' => $ivcf->incontinencia ?? null,
                    'problema_visao_impacto_atividades' => $ivcf->problema_visao_impacto_atividades ?? null,
                    'problema_audicao_impacto_atividades' => $ivcf->problema_audicao_impacto_atividades ?? null,
                    'doencas_cronicas_multiplas' => $ivcf->doencas_cronicas_multiplas ?? null,
                    'polifarmacia_5_ou_mais_medicamentos' => $ivcf->polifarmacia_5_ou_mais_medicamentos ?? null,
                    'internacao_ultimos_6_meses' => $ivcf->internacao_ultimos_6_meses ?? null,
                ],
            ],
            'procedimentos' => $atendimento ? AtendimentoIndividualProcedimento::where('atendimento_individual_id', $atendimento->id)
                ->get()
                ->map(function ($query) {
                    return [
                        'id' => $query->procedimento->id,
                        'codigo' => $query->procedimento->codigo ?? null,
                        'nome' => $query->procedimento->nome ?? null,
                    ];
                })
                ->sortBy('exame_nome')
                ->values() : [],
            'complemento' =>  $atendimento ? $atendimento->complemento : null,
        ];
    }

    public static function showAtendimento($id)
    {
        return AtendimentoIndividual::findOrFail($id);
    }

    public static function edit($id)
    {

        $atendimento = self::showAtendimento($id);

        $dataAtendimento = $atendimento->data_usuario_responsavel;

        $paciente = Paciente::findOrFail($atendimento->paciente->id);

         return [
            'additionals' => [
                'permissoes_atualizacao_cadastro_paciente' => self::getPermissoesAtualizacaoCadastroPaciente(),
                'paciente' => [
                    'sexo_id' => $paciente->cidadao->sexo_id,
                    'sexo_identificador' => $paciente->cidadao->sexo->identificador ?? null,
                    'data_nascimento' => $paciente->cidadao->data_nascimento
                        ? $paciente->cidadao->data_nascimento->format('d/m/Y')
                        : null
                ],
                'data_atual' => Carbon::now()->format('d/m/Y'),
            ],
            'form' => self::getFormData($paciente, $dataAtendimento, $atendimento),
            'model' => self::getModelData($atendimento, $paciente),
        ];
    }

    public static function show($id)
    {

        $atendimento = null;
        $paciente = Paciente::findOrFail($id);

        $dataAtendimento = Carbon::now()->format('Y-m-d');

         return [
            'additionals' => [
                'permissoes_atualizacao_cadastro_paciente' => self::getPermissoesAtualizacaoCadastroPaciente(),
                'paciente' => [
                    'sexo_id' => $paciente->cidadao->sexo_id,
                    'sexo_identificador' => $paciente->cidadao->sexo->identificador ?? null,
                    'data_nascimento' => $paciente->cidadao->data_nascimento
                        ? $paciente->cidadao->data_nascimento->format('d/m/Y')
                        : null
                ],
                'data_atual' => Carbon::now()->format('d/m/Y'),
            ],
            'form' => self::getFormData($paciente, $dataAtendimento, $atendimento),
            'model' => self::getModelData($atendimento, $paciente),
        ];
    }

    public static function store()
    {

        return self::saveStore(request()->all());
    }

    public static function saveStore($params)
    {

        self::validate($params);

        $params = (object) $params;

        $atendimento = $params->atendimento;

        $atendimentoIndividual = $atendimento['id']
            ? AtendimentoIndividual::findOrFail($atendimento['id'])
            : new AtendimentoIndividual();


        self::exceptionExamesSolicitadoAvaliado($params, $atendimento['exame_solicitado_avaliado']);
        self::exceptionCondicaoAvaliada($params, $atendimento['condicao_avaliada']);
        self::exceptionRastreamento($params, $atendimento['rastreamento']);

        $atendimentoIndividual->soap_id = $params->soap_id ?? null;
        $atendimentoIndividual->paciente_id = $params->paciente_id;

        $cadastro = $params->cadastro;
        $atendimentoIndividual->data_usuario_responsavel = $cadastro['data_usuario_responsavel'];

        $atendimentoIndividual->usuario_id = $cadastro['usuario_id'];
        $atendimentoIndividual->equipe_id = $cadastro['equipe_id'];
        $atendimentoIndividual->usuario_ocupacao_id = $cadastro['ocupacao_id'];

        $atendimentoIndividual->usuario_auxiliar_id = $cadastro['usuario_auxiliar_id'] ?? null ;
        $atendimentoIndividual->usuario_auxiliar_equipe_id = $cadastro['equipe_auxiliar_id'];
        $atendimentoIndividual->usuario_auxiliar_ocupacao_id = $cadastro['ocupacao_auxiliar_id'];

        $atendimentoIndividual->turno_id = $atendimento['turno_id'];
        $atendimentoIndividual->local_atendimento_id = $atendimento['local_atendimento_id'];
        $atendimentoIndividual->tipo_atendimento_id = $atendimento['tipo_atendimento_id'];
        $atendimentoIndividual->perimetro_cefalico = $atendimento['perimetro_cefalico'];
        $atendimentoIndividual->peso = $atendimento['peso'];
        $atendimentoIndividual->altura = $atendimento['altura'];
        $atendimentoIndividual->temperatura = $atendimento['temperatura'];
        $atendimentoIndividual->pressao_arterial = $atendimento['pressao_arterial'];
        $atendimentoIndividual->frequencia_respiratoria = $atendimento['frequencia_respiratoria'];
        $atendimentoIndividual->frequencia_cardiaca = $atendimento['frequencia_cardiaca'];
        $atendimentoIndividual->saturacao_o2 = $atendimento['saturacao_o2'];
        $atendimentoIndividual->circunferencia_abdominal = $atendimento['circunferencia_abdominal'];
        $atendimentoIndividual->perimetro_panturrilha = $atendimento['perimetro_panturrilha'];
        $atendimentoIndividual->glicemia = $atendimento['glicemia'];
        $atendimentoIndividual->momento_coleta_id = $atendimento['momento_coleta_id'];
        $atendimentoIndividual->vacinacao = $atendimento['vacinacao'];
        $atendimentoIndividual->modalidade_atencao_domiciliar_id = $atendimento['modalidade_atencao_domiciliar_id'];
        $atendimentoIndividual->aleitamento_materno_id = $atendimento['aleitamento_materno_id'];
        $atendimentoIndividual->racionalidade_saude_id = $atendimento['racionalidade_saude_id'];
        $atendimentoIndividual->data_ultima_menstruacao = $atendimento['dum'];
        $atendimentoIndividual->idade_gestacional_semanas = $atendimento['idade_gestacional_semanas'];
        $atendimentoIndividual->idade_gestacional_dias = $atendimento['idade_gestacional_dias'];
        $atendimentoIndividual->data_possivel_parto = $atendimento['data_possivel_parto'];
        $atendimentoIndividual->gravidez_planejada = $atendimento['gravidez_planejada'];
        $atendimentoIndividual->gestacao_previa = $atendimento['gestacao_previa'];
        $atendimentoIndividual->parto = $atendimento['parto'];
        $atendimentoIndividual->observacao = $atendimento['observacao'];
        $atendimentoIndividual->complemento = $params->complemento;
        $atendimentoIndividual->latitude = $atendimento['latitude'] ?? null;
        $atendimentoIndividual->longitude = $atendimento['longitude'] ?? null;
        $atendimentoIndividual->save();


        $atendimentoIndividual->condicaoAvaliada()->sync($atendimento['condicao_avaliada']);
        $atendimentoIndividual->doencaTransmissivel()->sync($atendimento['doenca_transmissivel']);
        $atendimentoIndividual->rastreamento()->sync($atendimento['rastreamento']);

        self::saveProblemasCondicoes($params, $atendimentoIndividual);

        AtendimentoIndividualExameSolicitadoAvaliado::where('atendimento_individual_id', $atendimentoIndividual->id)->delete();
        AtendimentoIndividualOutroExame::where('atendimento_individual_id', $atendimentoIndividual->id)->delete();
        AtendimentoIndividualTriagemNeonatal::where('atendimento_individual_id', $atendimentoIndividual->id)->delete();
        AtendimentoIndividualProcedimento::where('atendimento_individual_id', $atendimentoIndividual->id)->delete();

        self::saveExamesSolicitadoAvaliado($atendimento['exame_solicitado_avaliado'], $atendimentoIndividual);
        self::saveTriagemNeonatal($atendimento['triagem_neonatal'], $atendimentoIndividual);
        self::saveOutrosExames($atendimento['outros_exames'], $atendimentoIndividual);
        self::saveProcedimentos($params->procedimentos, $atendimentoIndividual);

        $condicao = $params->condicao;
        unset($condicao['cadastro_individual_id']);
        tap(CadastroIndividual::where('paciente_id', $params->paciente_id))->update($condicao);

        $atendimentoIndividual->nasf()->sync($atendimento['nasf']);
        $atendimentoIndividual->conduta()->sync($atendimento['conduta']);
        $atendimentoIndividual->encaminhamento()->sync($atendimento['encaminhamento']);

        if (!isset($params->origem) || $params->origem !== 'ambulatorio_atendimento_enfermagem') {
            self::storeProcedimentos($params, $atendimentoIndividual->id);
        }

        self::savePaciente($atendimento['dum'], $atendimentoIndividual);

        if (isset($atendimento['ivcf']['deseja_preencher']) && $atendimento['ivcf']['deseja_preencher'] === true) {
            AtendimentoIndividualIvcf::updateOrCreate(
                [
                    'atendimento_individual_id' => $atendimentoIndividual->id
                ],
                [
                    'atendimento_individual_id' => $atendimentoIndividual->id,
                    'estado_saude_geral' => $atendimento['ivcf']['estado_saude_geral'],
                    'limitacao_compras' => $atendimento['ivcf']['limitacao_compras'],
                    'limitacao_gestao_financeira' => $atendimento['ivcf']['limitacao_gestao_financeira'],
                    'limitacao_tarefas_domesticas' => $atendimento['ivcf']['limitacao_tarefas_domesticas'],
                    'banho_independencia' => $atendimento['ivcf']['banho_independencia'],
                    'relato_esquecimento_por_terceiros' => $atendimento['ivcf']['relato_esquecimento_por_terceiros'],
                    'esquecimento_piorando' => $atendimento['ivcf']['esquecimento_piorando'],
                    'esquecimento_impacta_atividades' => $atendimento['ivcf']['esquecimento_impacta_atividades'],
                    'humor_tristeza_desanimo' => $atendimento['ivcf']['humor_tristeza_desanimo'],
                    'perda_interesse_atividades' => $atendimento['ivcf']['perda_interesse_atividades'],
                    'limitacao_elevar_bracos' => $atendimento['ivcf']['limitacao_elevar_bracos'],
                    'limitacao_motricidade_fina' => $atendimento['ivcf']['limitacao_motricidade_fina'],
                    'perda_peso_nao_intencional' => $atendimento['ivcf']['perda_peso_nao_intencional'],
                    'imc_abaixo_22' => $atendimento['ivcf']['imc_abaixo_22'],
                    'panturrilha_abaixo_31' => $atendimento['ivcf']['panturrilha_abaixo_31'],
                    'marcha_lenta_4m_maior_5s' => $atendimento['ivcf']['marcha_lenta_4m_maior_5s'],
                    'dificuldade_caminhar_impacto_atividades' => $atendimento['ivcf']['dificuldade_caminhar_impacto_atividades'],
                    'quedas_recorrentes' => $atendimento['ivcf']['quedas_recorrentes'],
                    'incontinencia' => $atendimento['ivcf']['incontinencia'],
                    'problema_visao_impacto_atividades' => $atendimento['ivcf']['problema_visao_impacto_atividades'],
                    'problema_audicao_impacto_atividades' => $atendimento['ivcf']['problema_audicao_impacto_atividades'],
                    'doencas_cronicas_multiplas' => $atendimento['ivcf']['doencas_cronicas_multiplas'],
                    'polifarmacia_5_ou_mais_medicamentos' => $atendimento['ivcf']['polifarmacia_5_ou_mais_medicamentos'],
                    'internacao_ultimos_6_meses' => $atendimento['ivcf']['internacao_ultimos_6_meses'],
                ]
            );
        } else {
            AtendimentoIndividualIvcf::where('atendimento_individual_id', $atendimentoIndividual->id)->delete();
        }
    }

    private static function saveProblemasCondicoes($params, $atendimentoIndividual)
    {
        AtendimentoIndividualProblemaCondicao::where('atendimento_individual_id', $atendimentoIndividual->id)
            ->whereNotIn('id', collect($params->atendimento['problemas_condicoes'])->pluck('id')->filter())
            ->delete();

        foreach ($params->atendimento['problemas_condicoes'] as $problemaCondicao) {
            $problemaCondicaoAutomatico = isset($problemaCondicao['automatico']) ? $problemaCondicao['automatico'] : false;
            $problemaCondicaoAnteriorId = isset($problemaCondicao['problema_condicao_anterior_id']) ? $problemaCondicao['problema_condicao_anterior_id'] : null;
            $problemaCondicaoCiapId = isset($problemaCondicao['ciap_id']) ? $problemaCondicao['ciap_id'] : null;
            $problemaCondicaoCidId = isset($problemaCondicao['cid_id']) ? $problemaCondicao['cid_id'] : null;
            $problemaCondicaoSituacaoId = isset($problemaCondicao['situacao_id']) ? $problemaCondicao['situacao_id'] : null;
            $problemaCondicaoInicio = isset($problemaCondicao['inicio']) ? $problemaCondicao['inicio'] : null;
            $problemaCondicaoFim = isset($problemaCondicao['fim']) ? $problemaCondicao['fim'] : null;
            $problemaCondicaoObservacao = isset($problemaCondicao['observacao']) ? $problemaCondicao['observacao'] : null;

            $data = [
                'automatico' => $problemaCondicaoAutomatico,
                'ciap_id' => $problemaCondicaoCiapId,
                'cid_id' => $problemaCondicaoCidId,
                'situacao_id' => $problemaCondicaoSituacaoId,
            ];

            if (isset($problemaCondicao['soap_problema_condicao_id'])) {
                $data['soap_problema_condicao_id'] = $problemaCondicao['soap_problema_condicao_id'];
            }

            if (is_null($problemaCondicaoSituacaoId)) {
                $data['inicio'] = null;
                $data['fim'] = null;
                $data['observacao'] = null;
            }
            else {

                $data['inicio'] = is_null($problemaCondicaoInicio)
                    ? null
                    : Carbon::createFromFormat('d/m/Y', $problemaCondicaoInicio);

                $data['fim'] = is_null($problemaCondicaoFim)
                    ? null
                    : Carbon::createFromFormat('d/m/Y', $problemaCondicaoFim);

                $data['observacao'] = $problemaCondicaoObservacao;

                $data['uuid_evolucao'] = Str::uuid();

                if (!isset($problemaCondicao['id'])) {
                    if ($problemaCondicaoAnteriorId) {
                        $problemaCondicaoAnterior = AtendimentoIndividualProblemaCondicao::findOrFail($problemaCondicaoAnteriorId);

                        $data['uuid_inicial_problema_condicao'] = $problemaCondicaoAnterior->uuid_inicial_problema_condicao
                            ?? $problemaCondicaoAnterior->uuid_evolucao;

                        $data['sequencial_evolucao'] = $problemaCondicaoAnterior->sequencial_evolucao + 1;

                        $data['problema_condicao_anterior_id'] = $problemaCondicaoAnteriorId;

                        $data['problema_condicao_inicial_id'] = $problemaCondicaoAnterior->problema_condicao_inicial_id
                            ?? $problemaCondicaoAnterior->id;
                    }
                    else {
                        $data['sequencial_evolucao'] = 1;
                    }
                }
            }

            $atendimentoIndividual->problemasCondicoes()->updateOrCreate(
                ['id' => $problemaCondicao['id']],
                $data
            );
        }
    }

    private static function savePaciente($dum, $atendimentoIndividual) {

        if ($dum) {

            $atendimentoIndividual->paciente->dum()->updateOrCreate(
                ['paciente_id' => $atendimentoIndividual->paciente->id],
                ['data_ultima_menstruacao' => $dum]
            );

            if (self::isGestante($atendimentoIndividual)) {

                $CadastroPaciente = CadastroIndividual::where('paciente_id', $atendimentoIndividual['paciente_id']);

                if($CadastroPaciente){
                    $CadastroPaciente->update(['gestante' => true]);
                }

                if (!$atendimentoIndividual->paciente->cidadao->fatoresRisco->contains(FatorRiscoEnum::GESTANTE)) {

                    $atendimentoIndividual->paciente->cidadao->fatoresRisco()->attach(FatorRiscoEnum::GESTANTE);
                }
            }
        }
    }

    private static function isGestante($atendimentoIndividual) {

        if (!$atendimentoIndividual->paciente->cidadao->data_nascimento || !$atendimentoIndividual->paciente->cidadao->sexo_id) {
            return false;
        }

        $dataNascimento = new DateTime($atendimentoIndividual->paciente->cidadao->data_nascimento);
        $dataResponsavel = new DateTime($atendimentoIndividual->data_usuario_responsavel);
        $idade = $dataNascimento->diff($dataResponsavel)->y;

        return$atendimentoIndividual->paciente->cidadao->sexo->id === Sexo::FEMININO && ($idade >= 9 && $idade <= 60)
            &&  $atendimentoIndividual->condicaoAvaliada()->where('condicao_avaliada_id', EnumsCondicaoAvaliada::PRE_NATAL)->exists();
    }

    private static function saveTriagemNeonatal($triagemNeonatal, $atendimentoIndividual) {

        $obj = [];

        foreach ($triagemNeonatal as $triagem) {
            $tipo = substr($triagem, 0, 2);
            $id = substr($triagem, 2);

            $indice = array_search($id, array_column($obj, 'triagem_neonatal_id'));

            if ($indice !== false) {

                if ($tipo === 'a_') {
                    $obj[$indice]['avaliado'] = true;
                } elseif ($tipo === 's_') {
                    $obj[$indice]['solicitado'] = true;
                }
            } else {
                $novoObj = [
                    'triagem_neonatal_id' => $id,
                    'avaliado' => ($tipo === 'a_'),
                    'solicitado' => ($tipo === 's_')
                ];

                $obj[] = $novoObj;
            }
        }

        foreach ($obj as $ob) {

            $triagemNeoNatal = AtendimentoIndividualTriagemNeonatal::where('triagem_neonatal_id', $ob['triagem_neonatal_id'])
                ->where('atendimento_individual_id', $atendimentoIndividual->id)
                ->first() ?? new AtendimentoIndividualTriagemNeonatal();

            $triagemNeoNatal->triagem_neonatal_id = $ob['triagem_neonatal_id'];
            $triagemNeoNatal->atendimento_individual_id = $atendimentoIndividual->id;
            $triagemNeoNatal->avaliado = $ob['avaliado'];
            $triagemNeoNatal->solicitado = $ob['solicitado'];
            $triagemNeoNatal->save();
        }
    }

    private static function saveOutrosExames($exames, $atendimentoIndividual) {

        foreach ($exames as $exame) {

            $outroExame = AtendimentoIndividualOutroExame::where('exame_id', $exame['exame_id'])
                ->where('atendimento_individual_id', $atendimentoIndividual->id)
                ->first() ?? new AtendimentoIndividualOutroExame();

            $outroExame->exame_id = $exame['exame_id'];
            $outroExame->atendimento_individual_id = $atendimentoIndividual->id;
            $outroExame->avaliado = $exame['avaliado'];
            $outroExame->solicitado = $exame['solicitado'];
            $outroExame->save();
        }
    }

    private static function saveProcedimentos($procedimentos, $atendimentoIndividual) {

        foreach ($procedimentos as $procedimento) {

            $existe = AtendimentoIndividualProcedimento::where('procedimento_id', $procedimento['procedimento_id'])
                ->where('atendimento_individual_id', $atendimentoIndividual->id)
                ->first();

            if (!$existe) {

                $AtendimentoIndividualProcedimento = new AtendimentoIndividualProcedimento();
                $AtendimentoIndividualProcedimento->procedimento_id = $procedimento['procedimento_id'];
                $AtendimentoIndividualProcedimento->atendimento_individual_id = $atendimentoIndividual->id;
                $AtendimentoIndividualProcedimento->save();
            }
        }
    }

    private static function saveExamesSolicitadoAvaliado($exames, $atendimentoIndividual) {

        $obj = [];

        foreach ($exames as $exame) {
            $tipo = substr($exame, 0, 2);
            $id = substr($exame, 2);

            $indice = array_search($id, array_column($obj, 'exame_solicitado_avaliado_id'));

            if ($indice !== false) {

                if ($tipo === 'a_') {
                    $obj[$indice]['avaliado'] = true;
                } elseif ($tipo === 's_') {
                    $obj[$indice]['solicitado'] = true;
                }
            } else {
                $novoObj = [
                    'exame_solicitado_avaliado_id' => $id,
                    'avaliado' => ($tipo === 'a_'),
                    'solicitado' => ($tipo === 's_')
                ];

                $obj[] = $novoObj;
            }
        }

        foreach ($obj as $ob) {

            $exameSolicitadoAvaliado = AtendimentoIndividualExameSolicitadoAvaliado::where('exame_solicitado_avaliado_id', $ob['exame_solicitado_avaliado_id'])
                ->where('atendimento_individual_id', $atendimentoIndividual->id)
                ->first() ?? new AtendimentoIndividualExameSolicitadoAvaliado();

            $exameSolicitadoAvaliado->exame_solicitado_avaliado_id = $ob['exame_solicitado_avaliado_id'];
            $exameSolicitadoAvaliado->atendimento_individual_id = $atendimentoIndividual->id;
            $exameSolicitadoAvaliado->avaliado = $ob['avaliado'];
            $exameSolicitadoAvaliado->solicitado = $ob['solicitado'];
            $exameSolicitadoAvaliado->save();
        }
    }

    private static function storeProcedimentos($params, $atendimentoIndividualId) {

        $cadastro = $params->cadastro;
        $atendimento = $params->atendimento;
        $procedimentos = $params->procedimentos;
        $procedimentosFicha = [];

        foreach ($procedimentos as $procedimento) {

            $procedimentosFicha[] = [
                'id' => $procedimento['procedimento_id'],
                'quantidade' => 1,
            ];
        }

        $ficha = [
            'id' => null,
            'atendimento_individual_id' => $atendimentoIndividualId,
            'paciente_id' => $params->paciente_id,
            'data_usuario_responsavel' => $cadastro['data_usuario_responsavel'],
            'equipe_id' => $cadastro['equipe_id'],
            'ocupacao_id' => $cadastro['ocupacao_id'],
            'unidade_id' => $cadastro['unidade_id'],
            'usuario_id' => $cadastro['usuario_id'],
            'local_atendimento_id' => $atendimento['local_atendimento_id'],
            'afericao_pa' => $atendimento['pressao_arterial'],
            'altura' => $atendimento['altura'],
            'tipo_atendimento_id' => $atendimento['tipo_atendimento_id'],
            'curativo' => null,
            'exame_laboratorial' => null,
            'teste_rapido' => null,
            'procedimento_pequena_cirurgia' => null,
            'administracao_medicamento' => null,
            'peso' => $atendimento['peso'],
            'temperatura' => $atendimento['temperatura'],
            'perimetro_cefalico' => $atendimento['perimetro_cefalico'],
            'frequencia_respiratoria' => $atendimento['frequencia_respiratoria'],
            'frequencia_cardiaca' => $atendimento['frequencia_cardiaca'],
            'saturacao_o2' => $atendimento['saturacao_o2'],
            'circunferencia_abdominal' => $atendimento['circunferencia_abdominal'],
            'perimetro_panturrilha' => $atendimento['perimetro_panturrilha'],
            'glicemia' => $atendimento['glicemia'],
            'momento_coleta_id' => $atendimento['momento_coleta_id'],
            'microarea_id' =>  null,
            'escuta_inicial' =>  null,
            'turno_id' => $atendimento['turno_id'],
            'procedimentos' => $procedimentosFicha,
        ];

        $atendimento = [
            'id' => null,
            'origem' => 'atendimento_individual',
            'cadastro' => [
                'data_usuario_responsavel' => $cadastro['data_usuario_responsavel'],
                'equipe_id' => $cadastro['equipe_id'],
                'ocupacao_id' => $cadastro['ocupacao_id'],
                'unidade_id' => $cadastro['unidade_id'],
                'usuario_id' => $cadastro['usuario_id'],
            ],
            'atendimentos' => [$ficha],
            'procedimento_consolidado' => [
                'afericao_pa' => null,
                'altura' => null,
                'curativo' => null,
                'exame_laboratorial' => null,
                'glicemia_capilar' => null,
                'peso' => null,
                'temperatura' => null,
            ]
        ];

        ProcedimentoService::saveStore($atendimento);
    }

    private static function exceptionExamesSolicitadoAvaliado($params, $exames) {

        $paciente = Paciente::findOrFail($params->paciente_id);

        $obj = [];

        foreach ($exames as $exame) {
            $tipo = substr($exame, 0, 2);
            $id = substr($exame, 2);

            $indice = array_search($id, array_column($obj, 'exame_solicitado_avaliado_id'));

            if ($indice !== false) {

                if ($tipo === 'a_') {
                    $obj[$indice]['avaliado'] = true;
                } elseif ($tipo === 's_') {
                    $obj[$indice]['solicitado'] = true;
                }
            } else {
                $novoObj = [
                    'exame_solicitado_avaliado_id' => $id,
                    'avaliado' => ($tipo === 'a_'),
                    'solicitado' => ($tipo === 's_')
                ];

                $obj[] = $novoObj;
            }
        }

        foreach ($obj as $ob) {

            if ($ob['exame_solicitado_avaliado_id'] == EnumsExameSolicitadoAvaliado::TESTE_DE_GRAVIDEZ
                && $paciente->cidadao->sexo_id === Sexo::MASCULINO) {

                    $exame = ExameSolicitadoAvaliado::findOrFail($ob['exame_solicitado_avaliado_id']);

                    throw new ExameSolicitadoAvaliadoException(json_encode($exame->descricao));
            }
        }
    }

    private static function exceptionCondicaoAvaliada($params, $condicaoAvaliada) {

        $paciente = Paciente::findOrFail($params->paciente_id);

        foreach ($condicaoAvaliada as $condicao) {

            if (($condicao == EnumsCondicaoAvaliada::PRE_NATAL || $condicao == EnumsCondicaoAvaliada::PUERPERIO_ATE_42_DIAS)
                && $paciente->cidadao->sexo_id === Sexo::MASCULINO) {

                    $descriao = CondicaoAvaliada::findOrFail($condicao)->descricao;

                    throw new CondicaoAvaliadaException(json_encode($descriao));
            }
        }
    }

    private static function exceptionRastreamento($params, $rastreamento) {

        $paciente = Paciente::findOrFail($params->paciente_id);

        foreach ($rastreamento as $item) {

            if ($item == EnumsRastreamento::CANCER_COLO_UTERO && $paciente->cidadao->sexo_id === Sexo::MASCULINO) {

                $descriao = Rastreamento::findOrFail($item)->descricao;

                throw new RastreamentoException(json_encode($descriao));
            }
        }
    }

    public static function destroy($id)
    {
        DB::beginTransaction();

        try {
            $atendimentoIndividual = AtendimentoIndividual::findOrFail($id);

            DB::table('integracao_esus_inconsistencia_atendimento_individual')
                ->where('atendimento_individual_id', $id)
                ->delete();

            AtendimentoIndividualExameSolicitadoAvaliado::where('atendimento_individual_id', $id)->delete();
            AtendimentoIndividualOutroExame::where('atendimento_individual_id', $id)->delete();
            AtendimentoIndividualTriagemNeonatal::where('atendimento_individual_id', $id)->delete();
            AtendimentoIndividualProcedimento::where('atendimento_individual_id', $id)->delete();

            $procedimentoAtendimento = ProcedimentoAtendimento::where('atendimento_individual_id', $id)->first();

            if ($procedimentoAtendimento) {
                $procedimentoId = $procedimentoAtendimento->procedimento_id;

                ProcedimentoAtendimentoProcedimento::where('procedimento_atendimento_id', $procedimentoAtendimento->id)->delete();

                $procedimentoAtendimento->testesRapidos()->sync([]);
                $procedimentoAtendimento->pequenasCirurgias()->sync([]);
                $procedimentoAtendimento->administracaoMedicamentos()->sync([]);
                $procedimentoAtendimento->delete();

                $existeAtendimento = ProcedimentoAtendimento::where('procedimento_id', $procedimentoId)
                    ->first();

                if (!$existeAtendimento) {
                    ModelAtencaoBasicaProcedimento::where('id', $procedimentoId)->delete();
                }
            }

            $atendimentoIndividual->condicaoAvaliada()->sync([]);
            $atendimentoIndividual->doencaTransmissivel()->sync([]);
            $atendimentoIndividual->rastreamento()->sync([]);
            $atendimentoIndividual->nasf()->sync([]);
            $atendimentoIndividual->conduta()->sync([]);
            $atendimentoIndividual->encaminhamento()->sync([]);

            $atendimentoIndividual->delete();

            DB::commit();

        } catch (\Exception $e) {
            DB::rollBack();
            throw $e;
        }
    }

    private static function validate($params)
    {
        return Validator::make($params, [
            'cadastro.usuario_id' => [
                'required',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'cadastro.unidade_id' => [
                'required',
                'integer',
                Rule::exists(Unidade::class, 'id'),
            ],
            'cadastro.equipe_id' => [
                'required',
                'integer',
                Rule::exists(Equipe::class, 'id'),
            ],
            'cadastro.ocupacao_id' => [
                'required',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'cadastro.data_usuario_responsavel' => [
                'required',
                'date',
            ],
            'cadastro.usuario_auxiliar_id' => [
                'nullable',
                'integer',
                Rule::exists(Usuario::class, 'id'),
            ],
            'cadastro.usuario_auxiliar_unidade_id' => [
                'nullable',
                'required_if:cadastro.usuario_auxiliar_id, !=, null',
                'integer',
                Rule::exists(Unidade::class, 'id'),
            ],
            'cadastro.usuario_auxiliar_equipe_id' => [
                'nullable',
                'required_if:cadastro.usuario_auxiliar_id, !=, null',
                'integer',
                Rule::exists(Equipe::class, 'id'),
            ],
            'cadastro.usuario_auxiliar_ocupacao_id' => [
                'nullable',
                'required_if:cadastro.usuario_auxiliar_id, !=, null',
                'integer',
                Rule::exists(Ocupacao::class, 'id'),
            ],
            'atendimento.turno_id' => [
                'required',
                'integer',
                Rule::exists(Turno::class, 'id'),
            ],
            'atendimento.local_atendimento_id' => [
                'required',
                'integer',
                Rule::exists(LocalAtendimento::class, 'id'),
            ],
            'atendimento.tipo_atendimento_id' => [
                'required',
                'integer',
                Rule::exists(TipoAtendimento::class, 'id'),
            ],
            'atendimento.aleitamento_materno_id' => [
                'nullable',
                'integer',
                Rule::exists(AleitamentoMaterno::class, 'id'),
            ],
            'atendimento.racionalidade_id' => [
                'nullable',
                'integer',
                Rule::exists(RacionalidadeSaude::class, 'id'),
            ],
            'atendimento.condicao_avaliada' => [
                'nullable',
                'array',
                Rule::exists(CondicaoAvaliada::class, 'id'),
            ],
            'atendimento.doenca_transmissivel' => [
                'nullable',
                'array',
                Rule::exists(DoencaTransmissivel::class, 'id'),
            ],
            'atendimento.rastreamento' => [
                'nullable',
                'array',
                Rule::exists(Rastreamento::class, 'id'),
            ],
            'atendimento.nasf' => [
                'nullable',
                'array',
                Rule::exists(Nasf::class, 'id'),
            ],
            'atendimento.conduta' => [
                'nullable',
                'array',
                Rule::exists(Conduta::class, 'id'),
            ],
            'atendimento.encaminhamento' => [
                'nullable',
                'array',
                Rule::exists(Encaminhamento::class, 'id'),
            ],
            'atendimento.complemento' => [
                'nullable',
                'string',
                'max:1000'
            ],
            'atendimento.outrosExames' => [
                'nullable',
                'array',
                Rule::exists(Exame::class, 'id'),
            ],
            'atendimento.procedimento' => [
                'nullable',
                'array',
                Rule::exists(Procedimento::class, 'id'),
            ],
        ])->validate();
    }

    private static function getPermissoesAtualizacaoCadastroPaciente()
    {
        $parametrizacao = CnsService::getParametrizacao();

        if (!is_null($parametrizacao)) {
            $lotacao = self::getCurrentLotacao();

            return DB::table('cadastro_parametrizacao_permissao_usuario')
                ->select([
                    'municipe',
                    'provisorio',
                    'outro_municipio',
                ])
                ->where('infraestrutura_id', $lotacao->infraestrutura_id)
                ->where('usuario_id', $lotacao->usuario_id)
                ->get()
                ->first();
        }

        return null;
    }
}