<?php

namespace App\Services\Ambulatorio\AtendimentoEnfermagem;

use App\Enums\Ambulatorio\ProblemaCondicaoSituacao;
use App\Enums\Ambulatorio\TesteRapido as AmbulatorioTesteRapido;
use App\Enums\AtencaoBasica\AtendimentoIndividual\CondicaoAvaliada;
use App\Enums\AtencaoBasica\AtendimentoIndividual\TipoAtendimento;
use App\Enums\AtencaoBasica\ProcedimentoPequenaCirurgia;
use App\Enums\AtencaoBasica\TesteRapido as AtencaoBasicaTesteRapido;
use App\Enums\Geral\Ciap;
use App\Enums\Sigtap\Procedimento;
use App\Models\Administracao\Funcionalidade;
use App\Models\Ambulatorio\AtendimentoSoap;
use App\Models\Ambulatorio\ParametrizacaoInfraestruturaOcupacao;
use App\Models\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividual;
use App\Models\AtencaoBasica\AtendimentoIndividual\ExameSolicitadoAvaliado;
use App\Models\AtencaoBasica\AtendimentoIndividual\TriagemNeonatal;
use App\Models\AtencaoBasica\Avaliacao\Avaliacao;
use App\Models\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentar;
use App\Services\AtencaoBasica\AtendimentoDomiciliar\AtendimentoDomiciliarService;
use App\Services\AtencaoBasica\AtendimentoIndividual\AtendimentoIndividualService;
use App\Services\AtencaoBasica\Avaliacao\AvaliacaoService;
use App\Services\AtencaoBasica\MarcadorConsumoAlimentar\MarcadorConsumoAlimentarService;
use App\Services\AtencaoBasica\Procedimento\ProcedimentoService;
use App\Services\Service;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class EnfermagemAtencaoBasicaFichaService extends Service
{
    public static function store($soap, $data = [])
    {
        if (is_null($soap->equipe_id)) {

            return;
        }

        self::storeAtendimentoIndividual($soap, $data);
        self::storeProcedimento($soap);
        self::storeMarcadorConsumoAlimentar($soap, $data['marcador_consumo_alimentar']);
        self::storeAtendimentoDomiciliar($soap, $data);
        self::storeAvaliacao($soap, $data);
    }

    public static function storeAtendimentoIndividual($soap, $data)
    {

        if (!self::criaFicha($soap, 'atendimento-individual')) {

            return;
        }

        $getProcedimentos = function () use ($soap) {

            $procedimentos = collect();

            $soap->procedimentos()
                ->get()
                ->each(function ($atendimentoProcedimento) use ($procedimentos)  {

                    for ($i = 1; $i <= $atendimentoProcedimento->quantidade; $i++) {

                        $procedimentos->push([
                            'procedimento_id' => $atendimentoProcedimento->procedimento->id,
                        ]);
                    }
                });

            return $procedimentos->all();
        };

        $getDpp = function () use ($soap) {

            $ultimaDum = EnfermagemService::getUltimaDum($soap->atendimento->paciente);

            if (!is_null($ultimaDum)) {

                $ultimaDum = Carbon::createFromFormat('d/m/Y', $ultimaDum);

                return $ultimaDum->addMonths(9)->addDays(7)->format('Y-m-d');
            }

            return null;
        };

        $getCondicoesAvaliadas = function () use ($soap) {

            $condicoes = $soap->condicoesAvaliadas->pluck('id');

            if ($soap->is_atendimento_pre_natal) {

                $condicoes->push(CondicaoAvaliada::PRE_NATAL);
            }

            if ($soap->is_atendimento_puericultura) {

                $condicoes->push(CondicaoAvaliada::PUERICULTURA);
            }

            return $condicoes->all();
        };

        $getExamesAvaliados = function () use ($data, $soap) {

            $exames = [];

            foreach ($data['exame_avaliado'] as $avaliacao) {

                $exames[] = 'a_'. $avaliacao['id'];
            }

            foreach ($data['exame_solicitado']['exames']  as $solicitado) {

                $exames[] = 's_'. $solicitado['exame_id'];
            }

            foreach ($soap->solicitacoesExames as $solicitacao) {
                foreach ($solicitacao->itens as $item) {

                    if ($item->exame->codigo) {

                        $exameSolicitado = ExameSolicitadoAvaliado::where('codigo_procedimento', $item->exame->codigo)->first();

                        if ($exameSolicitado) {

                            $exames[] = 's_'. $exameSolicitado->id;
                        } else {

                            $exameSolicitado = TriagemNeonatal::where('codigo_procedimento', $item->exame->codigo)->first();

                            if ($exameSolicitado) {

                                $exames[] = 's_'. $exameSolicitado->id;
                            }
                        }
                    }
                }
            }

            foreach ($soap->resultadosExames as $solicitacao) {

                if ($solicitacao->exame->codigo) {

                    $exameSolicitado = ExameSolicitadoAvaliado::where('codigo_procedimento', $solicitacao->exame->codigo)->first();

                    if ($exameSolicitado) {

                        $exames[] = 'a_'. $exameSolicitado->id;
                    } else {

                        $exameSolicitado = TriagemNeonatal::where('codigo_procedimento', $solicitacao->exame->codigo)->first();

                        if ($exameSolicitado) {

                            $exames[] = 'a_'. $exameSolicitado->id;
                        }
                    }
                }
            }

            return $exames;
        };

        $getTriagensNeonatal = function () use ($data) {

            $exames = [];

            foreach ($data['triagem_neonatal'] as $avaliacao) {

                $exames[] = 'a_'. $avaliacao['id'];
            }

            foreach ($data['triagem_neonatal_solicitado']['exames']  as $solicitado) {

                $exames[] = 's_'. $solicitado['exame_id'];
            }

            return $exames;
        };

        $getOutrosExames = function () use ($soap) {
           
            $exames = collect();

            $soap->solicitacoesExames->each(function ($solicitacao) use ($exames) {

                $solicitacao->itens->each(fn ($item) => $exames->push([
                    'exame_id' => $item->exame_id,
                    'avaliado' => false,
                    'solicitado' => true,
                ]));
            });

            $soap->resultadosExames->each(function ($resultado) use ($exames) {

                if (is_null($resultado->exame->codigo)) {
                    return;
                }
                    
  
                $exames->push([
                    'exame_id' => $resultado->exame_id,
                    'avaliado' => true,
                    'solicitado' => false,
                ]);
            });

            return $exames;
        };

        $idadeGestacional = ['semanas' => null, 'dias' => null];
        $dataInicioGravidez = EnfermagemService::getDataInicioGravidezNaoResolvida($soap->atendimento->paciente);

        if (!is_null($dataInicioGravidez)) {

            $interval = Carbon::today()->diff(Carbon::createFromFormat('d/m/Y', $dataInicioGravidez));

            $idadeGestacional['semanas'] = (int) floor($interval->days / 7);
            $idadeGestacional['dias'] = $interval->days % 7;
        }

        $existeSoap = AtendimentoSoap::where('atendimento_id', $soap->atendimento_id)
        ->get(['id', 'turno_id'])
        ->toArray();

        $atIndividual = AtendimentoIndividual::whereIn('soap_id', array_column($existeSoap, 'id'))
        ->get(['id', 'turno_id', 'data_usuario_responsavel']);

        $atIndId = null;

        foreach ($atIndividual as $individual) {
            if ($individual->turno_id == $soap->turno_id &&
                $individual->data_usuario_responsavel == $soap->created_at->format('Y-m-d')) {

                $atIndId = $individual->id;
                break;
            }
        }

        $problemasCondicoes = $soap->problemasCondicoes()
            ->where(fn ($q) => $q
                ->doesntHave('ciap')
                ->orWhereHas('ciap', fn ($q) => $q
                    ->whereNotIn('codigo', [Ciap::GRAVIDEZ, Ciap::MEDICINA_PREVENTIVA_MANUTENCAO_DA_SAUDE])
                )
            )
            ->get()
            ->map(function ($problemaCondicao) use ($atIndId) {
                $problemaCondicaoAnteriorId = null;

                if ($problemaCondicao->problema_condicao_anterior_id) {
                    $problemaCondicaoAnteriorId = self::getProblemaCondicaoAnteriorId($problemaCondicao->problema_condicao_anterior_id, $atIndId);
                }

                return [
                    'id' => null,
                    'automatico' => $problemaCondicao->automatico,
                    'soap_problema_condicao_id' => $problemaCondicao->id,
                    'problema_condicao_anterior_id' => $problemaCondicaoAnteriorId,
                    'ciap_id' => $problemaCondicao->ciap_id,
                    'cid_id' => $problemaCondicao->cid_id,
                    'situacao_id' => $problemaCondicao->situacao_id,
                    'inicio' => $problemaCondicao->inicio
                        ? $problemaCondicao->inicio->format('d/m/Y')
                        : null,
                    'fim' => $problemaCondicao->fim
                        ? $problemaCondicao->fim->format('d/m/Y')
                        : null,
                    'observacao' => $problemaCondicao->observacao,
                ];
            })
            ->toArray();

        AtendimentoIndividualService::saveStore([
            'origem' => 'ambulatorio_atendimento_enfermagem',
            'soap_id' => $soap->id,
            'paciente_id' => $soap->atendimento->paciente->id,
            'complemento' => null,
            'procedimentos' => $getProcedimentos($soap),
            'condicao' => [
                'gestante' => EnfermagemService::isPacienteGestante($soap),
            ],
            'cadastro' => [
                'data_usuario_responsavel' => $soap->created_at->format('Y-m-d'),
                'unidade_id' => $soap->equipe->unidade_id,
                'usuario_id' => $soap->createdLotacao->usuario_id,
                'equipe_id' => $soap->equipe_id,
                'ocupacao_id' => $soap->createdLotacao->ocupacao_id,
                'usuario_auxiliar_id' => null,
                'equipe_auxiliar_id' => null,
                'ocupacao_auxiliar_id' => null,
            ],
            'atendimento' => [
                'id' => $atIndId,
                'turno_id' => $soap->turno_id,
                'local_atendimento_id' => $soap->atencao_basica_local_atendimento_id,
                'tipo_atendimento_id' => $soap->atendimento_tipo_id,
                'perimetro_cefalico' => $soap->objetivoAntropometria->atendimentoAntropometria->perimetro_cefalico ?? null,
                'circunferencia_abdominal' => $soap->objetivoAntropometria->atendimentoAntropometria->circunferencia_abdominal ?? null,
                'perimetro_panturrilha' => $soap->objetivoAntropometria->atendimentoAntropometria->perimetro_panturrilha ?? null,
                'peso' => $soap->objetivoAntropometria->atendimentoAntropometria->peso ?? null,
                'altura' => $soap->objetivoAntropometria->atendimentoAntropometria->altura ?? null,
                'temperatura' => $soap->objetivoSinalVital->atendimentoSinalVital->temperatura ?? null,
                'pressao_arterial' => $soap->objetivoSinalVital->atendimentoSinalVital->pressao_arterial ?? null,
                'frequencia_respiratoria' => $soap->objetivoSinalVital->atendimentoSinalVital->frequencia_respiratoria ?? null,
                'frequencia_cardiaca' => $soap->objetivoSinalVital->atendimentoSinalVital->frequencia_cardiaca ?? null,
                'saturacao_o2' => $soap->objetivoSinalVital->atendimentoSinalVital->saturacao_o2 ?? null,
                'glicemia' => $soap->objetivoGlicemiaCapilar->atendimentoGlicemiaCapilar->valor ?? null,
                'momento_coleta_id' => $soap->objetivoGlicemiaCapilar->atendimentoGlicemiaCapilar->momento_coleta_id ?? null,
                'vacinacao' => $soap->vacinacao_em_dia,
                'modalidade_atencao_domiciliar_id' => null,
                'aleitamento_materno_id' => $soap->puericultura_aleitamento_tipo_id,
                'racionalidade_saude_id' => $soap->racionalidade_saude_id,
                'dum' => $soap->dum ? $soap->dum->format('Y-m-d') : null,
                'idade_gestacional_semanas' => $idadeGestacional['semanas'],
                'idade_gestacional_dias' => $idadeGestacional['dias'],
                'data_possivel_parto' => $getDpp($soap),
                'gravidez_planejada' => $soap->pre_natal_gravidez_planejada,
                'gestacao_previa' => $soap->antecedente->gestas_previas ?? null,
                'parto' => $soap->antecedente->partos_realizados ?? null,
                'problemas_condicoes' => $problemasCondicoes,
                'observacao' => null,
                'condicao_avaliada' => $getCondicoesAvaliadas(),
                'doenca_transmissivel' => $soap->doencasTransmissiveis->pluck('id')->all(),
                'rastreamento' => $soap->rastreamentos->pluck('id')->all(),
                'exame_solicitado_avaliado' => $getExamesAvaliados(),
                'triagem_neonatal' => $getTriagensNeonatal(),
                'outros_exames' => $getOutrosExames(),
                'nasf' => [],
                'conduta' => $soap->condutas->pluck('id')->all(),
                'encaminhamento' => $soap->encaminhamentos->pluck('tipo_id')->all(),
                'ivcf' => array_merge(
                    [
                        'deseja_preencher' => $soap->ivcf ? true : false,
                    ],
                    $soap->ivcf ? $soap->ivcf->toArray() : [],
                ),
            ],
        ]);
    }

    private static function getProblemaCondicaoAnteriorId($soapProblemaCondicaoAnteriorId, $atendimentoIndividualId = null)
    {
        $problemaCondicaoAnteriorId = null;
        $problemaCondicaoAnterior = self::getProblemaCondicaoAtendendimentoIndividual($soapProblemaCondicaoAnteriorId, $atendimentoIndividualId);

        if (!is_null($problemaCondicaoAnterior)) {
            $problemaCondicaoAnteriorId = self::getLastProblemaCondicaoId($problemaCondicaoAnterior->id, $problemaCondicaoAnterior->situacao_id, $atendimentoIndividualId);
        }

        return $problemaCondicaoAnteriorId;
    }

    private static function getProblemaCondicaoAtendendimentoIndividual($soapProblemaCondicaoId, $atendimentoIndividualId = null)
    {
        $problemaCondicaoAtendimentoIndividual = DB::table('atencao_basica_atendimento_individual_problema_condicao')
            ->when($atendimentoIndividualId, fn ($q) => $q->where('atendimento_individual_id', '<>', $atendimentoIndividualId))
            ->where('soap_problema_condicao_id', $soapProblemaCondicaoId)
            ->select('id', 'situacao_id')
            ->first();

        if (is_null($problemaCondicaoAtendimentoIndividual)) {
            $problemaCondicaoSoap = DB::table('ambulatorio_atendimento_soap_problema_condicao')
                ->where('id', $soapProblemaCondicaoId)
                ->select('problema_condicao_anterior_id')
                ->first();

            if (isset($problemaCondicaoSoap->problema_condicao_anterior_id)) {
                return self::getProblemaCondicaoAtendendimentoIndividual($problemaCondicaoSoap->problema_condicao_anterior_id, $atendimentoIndividualId);
            }

            return null;
        }

        return $problemaCondicaoAtendimentoIndividual;
    }

    private static function getLastProblemaCondicaoId($id, $situacaoId, $atendimentoIndividualId = null)
    {
        $proximo = DB::table('atencao_basica_atendimento_individual_problema_condicao')
            ->when($atendimentoIndividualId, fn ($q) => $q->where('atendimento_individual_id', '<>', $atendimentoIndividualId))
            ->where('problema_condicao_anterior_id', $id)
            ->select('id', 'situacao_id')
            ->first();

        if (is_null($proximo)) {
            if ($situacaoId == ProblemaCondicaoSituacao::RESOLVIDO) {
                return null;
            }
            else {
                return $id;
            }
        }

        return self::getLastProblemaCondicaoId($proximo->id, $proximo->situacao_id, $atendimentoIndividualId);
    }

    public static function storeProcedimento($soap)
    {
        if (!self::criaFicha($soap, 'procedimento')) {

            return;
        }

        $procedimentosParaIgnorar = collect();
        $hasProcedimentoColetaMaterialExameLaboratoriao = false;

        $procedimentosParaIgnorar->push(Procedimento::ESCUTA_INICIAL_ORIENTACAO_ACOLHIMENTO_A_DEMANDA_ESPONT_NEA);

        $getPequenasCirurgias = function () use ($soap, $procedimentosParaIgnorar) {

            $pequenasCirurgias = collect();

            if ($soap->orientacao_individual_em_saude) {

                $pequenasCirurgias->push(ProcedimentoPequenaCirurgia::ORIENTACAO_INDIVIDUAL_EM_SAUDE);
            }

            return $pequenasCirurgias;
        };

        $getTestesRapidos = function () use ($soap, $procedimentosParaIgnorar) {

            $testesRapidos = collect();
            $testesRapidosSoap = $soap->testesRapidos()->get(['id', 'codigo']);

            if ($procedimento = $testesRapidosSoap->where('id', AmbulatorioTesteRapido::GRAVIDEZ)->first()) {

                $procedimentosParaIgnorar->push($procedimento->codigo);
                $testesRapidos->push(AtencaoBasicaTesteRapido::GRAVIDEZ);
            }

            if ($procedimento = $testesRapidosSoap->where('id', AmbulatorioTesteRapido::DETECCAO_DE_HEPATITE_C)->first()) {

                $procedimentosParaIgnorar->push($procedimento->codigo);
                $testesRapidos->push(AtencaoBasicaTesteRapido::HEPATITE_C);
            }

            if ($procedimento = $testesRapidosSoap->where('id', AmbulatorioTesteRapido::DETECCAO_DE_INFECCAO_PELO_HIV)->first()) {

                $procedimentosParaIgnorar->push($procedimento->codigo);
                $testesRapidos->push(AtencaoBasicaTesteRapido::HIV);
            }

            if ($procedimento = $testesRapidosSoap->where('id', AmbulatorioTesteRapido::SIFILIS)->first()) {

                $procedimentosParaIgnorar->push($procedimento->codigo);
                $testesRapidos->push(AtencaoBasicaTesteRapido::SIFILIS);
            }

            if ($procedimento = $testesRapidosSoap->where('id', AmbulatorioTesteRapido::DETECCAO_DE_INFECCAO_PELO_HBV)->first()) {

                $procedimentosParaIgnorar->push($procedimento->codigo);
                $testesRapidos->push(AtencaoBasicaTesteRapido::HEPATITE_B);
            }

            if ($procedimento = $testesRapidosSoap->where('id', AmbulatorioTesteRapido::PROTEINURIA)->first()) {

                $procedimentosParaIgnorar->push($procedimento->codigo);
                $testesRapidos->push(AtencaoBasicaTesteRapido::DOSAGEM_PROTEINURIA);
            }

            if ($procedimento = $testesRapidosSoap->where('id', AmbulatorioTesteRapido::TESTE_DO_OLHINHO_TRV)->first()) {

                $procedimentosParaIgnorar->push($procedimento->codigo);
                $testesRapidos->push(AtencaoBasicaTesteRapido::TESTE_OLHINHO_TRV);
            }

            return $testesRapidos;
        };

        $getProcedimentos = function () use ($soap, $procedimentosParaIgnorar, &$hasProcedimentoColetaMaterialExameLaboratoriao) {

            $procedimentos = collect();

            $soap->procedimentos()
                ->get()
                ->reject(fn ($p) => $procedimentosParaIgnorar->contains($p->procedimento->codigo))
                ->each(function ($atendimentoProcedimento) use ($soap, $procedimentos, &$hasProcedimentoColetaMaterialExameLaboratoriao)  {

                    if ($atendimentoProcedimento->procedimento->codigo === Procedimento::COLETA_DE_MATERIAL_PARA_EXAME_LABORATORIAL) {

                        $hasProcedimentoColetaMaterialExameLaboratoriao = true;
                    }

                    for ($i = 1; $i <= $atendimentoProcedimento->quantidade; $i++) {

                        $procedimentos->push([
                            'soap_id' => $soap->id,
                            'procedimento_id' => $atendimentoProcedimento->procedimento->id
                        ]);
                    }
                });

            return $procedimentos;
        };

        $pequenasCirurgias = $getPequenasCirurgias();
        $testesRapidos = $getTestesRapidos();
        $procedimentos = $getProcedimentos();

        ProcedimentoService::saveFromAmbulatorioAtendimentoEnfermagem([
            'cadastro' => [
                'soap_id' => $soap->id,
                'data_usuario_responsavel' => $soap->created_at->format('Y-m-d'),
                'usuario_id' => $soap->createdLotacao->usuario_id,
                'equipe_id' => $soap->equipe_id,
                'ocupacao_id' => $soap->createdLotacao->ocupacao_id,
            ],
            'atendimentos' => [
                [
                    'soap_id' => $soap->id,
                    'paciente_id' => $soap->atendimento->paciente->id,
                    'turno_id' => $soap->turno_id,
                    'local_atendimento_id' => $soap->atencao_basica_local_atendimento_id,
                    'microarea_id' => is_null($soap->atendimento->paciente->cidadao->domicilio_id)
                        ? null
                        : ProcedimentoService::getCadastroDomiciliar([
                            'domicilio_id' => $soap->atendimento->paciente->cidadao->domicilio_id,
                            'profissional_equipe_id' => $soap->equipe_id,
                        ])['microarea_id'] ?? null,
                    'escuta_inicial' => $soap->atendimento_tipo_id === TipoAtendimento::ESCUTA_INICIAL_ORIENTACAO,
                    'peso' => $soap->objetivoAntropometria->atendimentoAntropometria->peso ?? null,
                    'altura' => $soap->objetivoAntropometria->atendimentoAntropometria->altura ?? null,
                    'temperatura' => $soap->objetivoSinalVital->atendimentoSinalVital->temperatura ?? null,
                    'afericao_pa' => $soap->objetivoSinalVital->atendimentoSinalVital->pressao_arterial ?? null,
                    'frequencia_respiratoria' => $soap->objetivoSinalVital->atendimentoSinalVital->frequencia_respiratoria ?? null,
                    'frequencia_cardiaca' => $soap->objetivoSinalVital->atendimentoSinalVital->frequencia_cardiaca ?? null,
                    'saturacao_o2' => $soap->objetivoSinalVital->atendimentoSinalVital->saturacao_o2 ?? null,
                    'glicemia' => $soap->objetivoGlicemiaCapilar->atendimentoGlicemiaCapilar->valor ?? null,
                    'momento_coleta_id' => $soap->objetivoGlicemiaCapilar->atendimentoGlicemiaCapilar->momento_coleta_id ?? null,
                    'perimetro_cefalico' => $soap->objetivoAntropometria->atendimentoAntropometria->perimetro_cefalico ?? null,
                    'circunferencia_abdominal' => $soap->objetivoAntropometria->atendimentoAntropometria->circunferencia_abdominal ?? null,
                    'perimetro_panturrilha' => $soap->objetivoAntropometria->atendimentoAntropometria->perimetro_panturrilha ?? null,
                    'exame_laboratorial' => $hasProcedimentoColetaMaterialExameLaboratoriao,
                    'teste_rapido' => $testesRapidos->all(),
                    'procedimento_pequena_cirurgia' => $pequenasCirurgias->all(),
                    'administracao_medicamento' => null,
                    'procedimentos' => $procedimentos->all(),
                ],
            ],
        ]);
    }

    public static function storeMarcadorConsumoAlimentar($soap, $data)
    {
        if (!self::criaFicha($soap, 'marcador-consumo-alimentar')) {

            return;
        }

        $existeSoap = AtendimentoSoap::where('atendimento_id', $soap->atendimento_id)
        ->get(['id', 'turno_id'])
        ->toArray();

        $mConsumo = MarcadorConsumoAlimentar::whereIn('soap_id', array_column($existeSoap, 'id'))
        ->get(['id', 'soap_id','data_atendimento'])
        ->map(function ($item) use ($existeSoap) {
            $soap = collect($existeSoap)->firstWhere('id', $item->soap_id);
            $item->turno_id = $soap['turno_id'] ?? null;
            return $item;
        });

        $marCon = null;

        foreach ($mConsumo as $marConsumo) {
            if ($marConsumo->turno_id == $soap->turno_id
            && $marConsumo->data_atendimento == $soap->created_at->format('Y-m-d')) {

                $marCon = $marConsumo->id;
                break;
            }
        }

        $respostaUnica = array_filter($data['pergunta_unica'], fn ($valor) => $valor !== null);
        $respostaMultipla = array_filter($data['pergunta_multipla'], fn ($valor) => $valor !== null);

        if ((!empty($respostaUnica) || !empty($respostaMultipla)) && empty($marCon)) {

            MarcadorConsumoAlimentarService::saveStore([
                'soap_id' => $soap->id,
                'data_atendimento' => $soap->created_at->format('Y-m-d'),
                'local_atendimento' =>  $soap->atencao_basica_local_atendimento_id,
                'paciente' => $soap->atendimento->paciente->id,
                'usuario' => $soap->createdLotacao->usuario_id,
                'cbo_codigo' => $soap->createdLotacao->ocupacao_id,
                'unidade' => $soap->createdLotacao->infraestrutura->unidade_id,
                'equipe' => $soap->equipe_id,
                'pergunta' => [
                    'resposta_unica' => $respostaUnica,
                    'resposta_multipla' => $respostaMultipla,
                ],
            ]);
        }elseif((!empty($respostaUnica) || !empty($respostaMultipla)) && !empty($marCon)) {

            MarcadorConsumoAlimentarService::update($marCon,[
                'soap_id' => $soap->id,
                'data_atendimento' => $soap->created_at->format('Y-m-d'),
                'local_atendimento' =>  $soap->atencao_basica_local_atendimento_id,
                'paciente' => $soap->atendimento->paciente->id,
                'usuario' => $soap->createdLotacao->usuario_id,
                'cbo_codigo' => $soap->createdLotacao->ocupacao_id,
                'unidade' => $soap->createdLotacao->infraestrutura->unidade_id,
                'equipe' => $soap->equipe_id,
                'pergunta' => [
                    'resposta_unica' => $respostaUnica,
                    'resposta_multipla' => $respostaMultipla,
                ],
            ]);
        }
    }

    public static function storeAtendimentoDomiciliar($soap, $data)
    {
        if (!self::criaFicha($soap, 'atendimento-domiciliar')) {

            return;
        }

        $atendimentos = [];
        $problemas_condicoes = [];

        foreach ($data['problemas_condicoes'] as $problemaCondicao) {
            $problemas_condicoes[] = [
                'id' => $problemaCondicao['id'],
                'ciap' => ['id' => $problemaCondicao['ciap_id']],
                'cid' => ['id' => $problemaCondicao['cid_id']],
            ];
        }

        $atendimentos[] = [
            'data' => $soap->created_at->format('Y-m-d'),
            'paciente_id' => $soap->atendimento->paciente->id,
            'local_atendimento_id' => $soap->atencao_basica_local_atendimento_id,
            'tipo_atendimento_id' => $soap->emad_tipo_atendimento_id,
            'modalidade_id' => $soap->emad_modalidade_id,
            'turno_id' => $soap->turno_id,
            'conduta_desfecho_id' => $soap->emad_conduta_desfecho_id,
            'codigo_cid' => $soap->cid ?? null,
            'codigo_ciap' => $soap->ciap ?? null,
            'procedimentos' => $data['procedimentos_emad'],
            'condicoes' => $data['condicoes_emad'],
            'problemas_condicoes' => $problemas_condicoes,
            'condicao_avaliada' => $data['condicoes_avaliadas'],
            'doenca_transmissivel' => $data['doencas_transmissiveis'],
            'rastreamento' => $data['rastreamentos'],
            'observacao_perfil_epidemiologico' => $soap->observacao_perfil_epidemiologico,
            'perfis_epidemiologicos' => $soap->perfisEpidemiologicos->pluck('id'),
            'ivcf' => array_merge(
                [
                    'deseja_preencher' => $soap->ivcf ? true : false,
                ],
                $soap->ivcf ? $soap->ivcf->toArray() : [],
            ),
        ];

        AtendimentoDomiciliarService::saveStore([
            'soap_id' => $soap->id,
            'data' => $soap->created_at->format('Y-m-d'),
            'usuario_id' => $soap->createdLotacao->usuario_id,
            'equipe_id' => $soap->equipe_id,
            'ocupacao_id' => $soap->createdLotacao->ocupacao_id,
            'usuario_auxiliar_id' => null,
            'equipe_auxiliar_id' => null,
            'ocupacao_auxiliar_id' => null,
            'atendimentos' => $atendimentos,
        ]);
    }

    public static function storeAvaliacao($soap, $data)
    {
        $hasAvaliacao = Avaliacao::where('paciente_id', $soap->atendimento->paciente->id)->first() ? true : false;

        if (!self::criaFicha($soap, 'avaliacao') || $hasAvaliacao || !$data['ficha_avaliacao']) {

            return;
        }

        AvaliacaoService::saveStore([
            'soap_id' => $soap->id,
            'data' => $soap->created_at->format('Y-m-d'),
            'usuario_id' => $soap->createdLotacao->usuario_id,
            'equipe_id' => $soap->equipe_id,
            'unidade_id' => $soap->createdLotacao->infraestrutura->unidade_id,
            'infraestrutura_id' => $soap->createdLotacao->infraestrutura->id,
            'ocupacao_id' => $soap->createdLotacao->ocupacao_id,
            'usuario_auxiliar_id' => null,
            'equipe_auxiliar_id' => null,
            'ocupacao_auxiliar_id' => null,
            'condicoes' => $data['condicoes_emad'],
            'condicao_avaliada' => $data['condicoes_avaliadas'],
            'data' => $soap->created_at->format('Y-m-d'),
            'paciente_id' => $soap->atendimento->paciente->id,
            'turno_id' => $soap->turno_id,
            'cid_primario' => $soap->emad_cid_primario_id,
            'conclusao_id' => $soap->emad_conclusao_id,
            'procedencia_id' => $soap->emad_procedencia_id,
            'cuidador_id' => $soap->emad_cuidador_id,
            'cpf_cuidador' => $soap->emad_cpf_cuidador,
            'cns_cuidador' => $soap->emad_cns_cuidador,
            'justificativa' => $data['emad_conclusao_justificativa'],
        ]);
    }

    private static function criaFicha($soap, $funcionalidadeIdentificador)
    {
        return ParametrizacaoInfraestruturaOcupacao::whereHas('parametrizacaoInfraestrutura', fn ($q) => $q
                ->where('infraestrutura_id', $soap->createdLotacao->infraestrutura_id)
            )
            ->where('ocupacao_id', $soap->createdLotacao->ocupacao_id)
            ->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;
    }
}