using adas_core.Application.Services.Interfaces;
using adas_core.Domain.Enums;
using adas_core.Domain.Models;
using adas_core.Domain.Models.AppSettings;
using adas_core.Domain.Models.Pumps;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using MongoDB.Bson;
using MongoDB.Driver;

namespace adas_core.Application.Customizations.HUVH.UCIA;

public class CalculatedObservations : ICalculatedObservations
{
    private const string CodingSystem = "ADAS";
    private readonly List<string>? _antibioticList;
    private readonly List<string>? _antidepressantsList;
    private readonly List<string>? _antihypertensivesList;
    private readonly List<string>? _antipsicoticList;
    private readonly List<string>? _anxiolyticsList;
    private readonly List<string>? _inotropicMedicines;
    private readonly ILogger<CalculatedObservations> _logger;
    private readonly Lazy<IMedicineService> _medicineService;
    private readonly List<string>? _neuroMedicationList;
    private readonly Lazy<IObservationService> _observationService;

    private readonly List<string>? _sedationList;
    private readonly List<string>? _serumColloidList;
    private readonly List<string>? _serumCrystalloidList;

    private readonly Lazy<ITreatmentService> _treatmentService;

    public CalculatedObservations(IServiceProvider serviceProvider)
    {
        _treatmentService = serviceProvider.GetRequiredService<Lazy<ITreatmentService>>();
        _medicineService = serviceProvider.GetRequiredService<Lazy<IMedicineService>>();
        _observationService = serviceProvider.GetRequiredService<Lazy<IObservationService>>();
        _logger = serviceProvider.GetRequiredService<ILogger<CalculatedObservations>>();

        var apiSettings = serviceProvider.GetRequiredService<IOptions<ApiSettings>>(); //apiSettings;

        _sedationList = apiSettings.Value.Sedation;
        _inotropicMedicines = apiSettings.Value.InotropicMedicines;
        _antibioticList = apiSettings.Value.AntibioticList;
        _anxiolyticsList = apiSettings.Value.AnxiolyticList;
        _antipsicoticList = apiSettings.Value.AntipsicoticList;
        _antidepressantsList = apiSettings.Value.AntidepressantsList;
        _neuroMedicationList = apiSettings.Value.NeuroMedicationList;
        _serumCrystalloidList = apiSettings.Value.SerumCrystalloidList;
        _serumColloidList = apiSettings.Value.SerumColloidList;
        _antihypertensivesList = apiSettings.Value.AntihypertensivesList;
    }


    public Task CalculateActiveBolus(ObjectId patientId)
    {
        throw new NotImplementedException();
    }


    public async Task<T?> Map<T>(T obs, bool onlyByName = false) where T : BasePatientObservation
    {
        if (obs.Name is "PSI" or "RASS" or "TS") _ = CalculateOverSedation(obs);

        if (obs.Name is "Inspiratory_Pressure" or "Compliancia" or "Air_Flow") _ = CalculateVentilationMode(obs);

        if (obs.Name is "ECMO_Location" or "Location_Drainage_Cannula" or "Location_Return_Cannula")
            obs = (T)await CalculateEcmoLocation(obs);

        if (obs.Name is "EVN" or "ANI" or "ESCID") _ = CalculateOverAnalgesia(obs);

        if (obs.Name is "Pmeset" or "PEEP") _ = CalculateDrivingPressure(obs);

        if (obs.Name is "SpO2_FiO2_Ratio" or "FR") _ = CalculateRoxIndex(obs);

        if (obs.Name is "Diuresis") _ = CalculateDiuresis(obs);

        if (obs.Name is "Rehabilitation") obs = (T)await CalculateRehabilitationAlarm(obs);

        return obs;
    }

    public async Task<PatientTreatment> Map(PatientTreatment treatment)
    {
        var order = treatment.PlacerOrder?.EntityIdentifier; //aquí almacenamos el número de orden
        if (string.IsNullOrEmpty(order)) return treatment;

        //comprobamos el estado de los tratamientos anteriores
        var oldTreatments = await CheckExpiredPatientTreatments(treatment);

        treatment.OrderControl = oldTreatments.Any() ? OrderControlType.Xo : OrderControlType.Nw;

        if (treatment.EndTime != null)
            //el tratamiento ha expirado
            treatment.OrderControl = OrderControlType.Dc;

        await CheckTreatmentMedicines(treatment);

        return treatment;
    }

    public async Task<PumpObservation> Map(PumpObservation pumpObservation)
    {
        return await Task.FromResult(pumpObservation);

    }

    public Task CalculateMedicineObservation(List<Medicine> activeMedicines, ObjectId patientId)
    {
        //Esto viene del schedulerService para chequear los medicamentos activos
        CheckMedicationCategories(patientId, activeMedicines);

        return Task.CompletedTask;
    }

    public async Task<IEnumerable<PatientTreatment?>> GetActiveTreatmentsByPatient(ObjectId id)
    {
        var activeTreatments = await _treatmentService.Value.GetActiveTreatmentsByPatient(id);
        return activeTreatments;
    }


    public Task<PatientDiagnosis> Map(PatientDiagnosis diagnosis)
    {
        throw new NotImplementedException();
    }

   

    public async Task<PatientObservation?> FixTimeInconsistencyWithLast(PatientObservation newObservation)
    {
        if (string.IsNullOrEmpty(newObservation.Name))
        {
            _logger.LogError(
                "Error FixTimeInconsistencyWithLast. Observation name is null or empty. Observation: {newObservation}",
                newObservation);
            return newObservation;
        }

        var lastObservations = await _observationService.Value.FindLastObservations(newObservation.PatientId, 1,
            [newObservation.Name]);
        var lastObservation = lastObservations.FirstOrDefault();

        if (lastObservation != null && DateTime.Compare(
                new DateTime(lastObservation.Time.Year, lastObservation.Time.Month,
                    lastObservation.Time.Day, lastObservation.Time.Hour,
                    lastObservation.Time.Minute, lastObservation.Time.Second),
                new DateTime(newObservation.Time.Year, newObservation.Time.Month,
                    newObservation.Time.Day, newObservation.Time.Hour,
                    newObservation.Time.Minute, newObservation.Time.Second)
            ) >= 0)
            newObservation.Time = lastObservation.Time.AddSeconds(1);

        return newObservation;
    }

    public Task<List<PatientObservation>> PreMapList(List<PatientObservation> listToInsert)
    {
        return Task.FromResult(listToInsert);
    }

    public Task<PatientObservation> MapSourceAlarm(PatientObservation obs, PatientObservationAlarm alarmToInsert)
    {
        return Task.FromResult(obs);
    }

    public Task SendAlarm(PatientObservation obs, string name, AlarmEnum.Name? code)
    {
        throw new NotImplementedException();
    }

    private async Task<BasePatientObservation> CalculateRehabilitationAlarm(BasePatientObservation obs)
    {
        //En rojo si el grado es de 0 a 2 incluidos, por más de 7 días

        if (obs is not PatientObservation pobs || !int.TryParse(pobs.Value.ToString(), out var pobsValue) ||
            pobsValue > 2) return obs;

        var result = await _observationService.Value.FindLastObservations(obs.PatientId, 6, ["Rehabilitation"]);

        var obsInAlert = result.Count(o =>
            int.TryParse(o.Value.ToString(), out var oValue) && oValue is >= 0 and <= 2);
        if (obsInAlert == 6) pobs.Status = StatusEnum.Type.Alert;

        return obs;
    }

    private async Task CalculateDiuresis(BasePatientObservation obs)
    {
        // Calculado como el sumatorio de la Diuresis de las últimas 6h 
        // entre el último peso medido del paciente y entre 6. Medido en ml/kg/h
        // Valor = sum(Diuresis últimas 6 horas) / Weight / 6

        if (obs is not PatientObservation pobs)
            return;

        double weightValue = 0;
        var numValues = pobs.Name switch
        {
            "Diuresis" => 2, // Si la observación entrante es "Diuresis", necesitamos las 2 últimas para completar 6h.
            "Weight" => 3, // Si la observación entrante es "Weight", necesitamos las 3 últimas de "Diuresis".
            _ => 0
        };

        if (numValues == 0)
            return; // Si no es ni Diuresis ni Weight, no aplicamos cálculo.

        // Obtener las observaciones de diuresis necesarias
        var diuresisObservations =
            await _observationService.Value.FindLastObservations(pobs.PatientId, numValues, ["Diuresis"]);
        var diuresisValues = diuresisObservations
            .Select(o => double.TryParse(o.Value.ToString(), out var value) ? value : 0)
            .ToList();

        if (pobs.Name == "Diuresis")
        {
            // Si la observación entrante es Diuresis, la agregamos
            if (double.TryParse(pobs.Value.ToString(), out var currentDiuresis))
                diuresisValues.Insert(0, currentDiuresis);

            // Buscar el último peso registrado
            var weightObservations =
                await _observationService.Value.FindLastObservations(pobs.PatientId, 1, ["Weight"]);
            var weightObs = weightObservations.FirstOrDefault();
            if (weightObs != null && double.TryParse(weightObs.Value.ToString(), out var wObsValue))
                weightValue = wObsValue;
        }
        else if (pobs.Name == "Weight" && double.TryParse(pobs.Value.ToString(), out var wValue))
        {
            // Si la observación entrante es Weight, asignamos su valor directamente.
            weightValue = wValue;
        }

        // Validaciones antes de calcular
        if (diuresisValues.Count < 3)
        {
            _logger.LogWarning("Calculated Diuresis lacks sufficient values. Required: 3, Found: {count}",
                diuresisValues.Count);
            return;
        }

        if (weightValue <= 0)
        {
            _logger.LogWarning("Calculated Diuresis aborted due to invalid weight value: {weight}", weightValue);
            return;
        }

        // Cálculo del índice de diuresis
        var diuresisIndex = diuresisValues.Sum() / weightValue / 6;

        var diuresisObs = new PatientObservation
        {
            PatientId = pobs.PatientId,
            Time = DateTime.UtcNow,
            CodingSystem = CodingSystem,
            Name = "Calculated_Diuresis",
            Value = diuresisIndex
        };

        await _observationService.Value.InsertObservation(diuresisObs, mapObs: false);
    }


    private async Task CalculateRoxIndex(BasePatientObservation obs)
    {
        // Cálculo dividiendo el ratio SpO2/FiO2 entre la FR
        // Valor = (SpO2_FiO2_Ratio) / FR

        if (obs is not PatientObservation pobs)
            return;

        List<string>? requiredObservations = pobs.Name switch
        {
            "SpO2_FiO2_Ratio" => ["FR"], // Si la observación actual es SpO2_FiO2_Ratio, necesitamos FR
            "FR" => ["SpO2_FiO2_Ratio"], // Si la observación actual es FR, necesitamos SpO2_FiO2_Ratio
            _ => null
        };

        if (requiredObservations is null)
            return;

        var result = await _observationService.Value.FindLastObservations(pobs.PatientId, 1, requiredObservations);
        var targetObs = result.FirstOrDefault();

        if (targetObs == null || !double.TryParse(targetObs.Value.ToString(), out var targetValue))
            return;

        // Determinar los valores necesarios para el cálculo
        var spo2FiO2Ratio = pobs.Name == "SpO2_FiO2_Ratio"
            ? double.TryParse(pobs.Value.ToString(), out var ratio) ? ratio : 0
            : targetValue;

        var fr = pobs.Name == "FR"
            ? double.TryParse(pobs.Value.ToString(), out var frValue) ? frValue : 0
            : targetValue;

        if (fr == 0) // Evita división por cero
            return;

        var roxIndexObs = new PatientObservation
        {
            PatientId = pobs.PatientId,
            Time = DateTime.UtcNow,
            CodingSystem = CodingSystem,
            Name = "Rox_Index",
            Value = spo2FiO2Ratio / fr
        };

        await _observationService.Value.InsertObservation(roxIndexObs, mapObs: false);
    }

    private async Task CalculateDrivingPressure(BasePatientObservation obs)
    {
        //Diferencia entre la Pmeset y la PEEP
        //Calculo Valor = Pmeset - PEEP

        try
        {
            if (obs is not PatientObservation pobs)
                return;

            var targetObservation = pobs.Name switch
            {
                "Pmeset" => "PEEP",
                "PEEP" => "Pmeset",
                _ => null
            };

            if (targetObservation is null)
                return;

            var resultList =
                await _observationService.Value.FindLastObservations(obs.PatientId, 1, [targetObservation]);
            var targetObs = resultList.FirstOrDefault();
            if (targetObs == null || !int.TryParse(targetObs.Value.ToString(), out var targetValue))
                return;

            var peepValue = pobs.Name == "PEEP"
                ? int.TryParse(pobs.Value.ToString(), out var peep) ? peep : 0
                : targetValue;
            var pmesetValue = pobs.Name == "Pmeset"
                ? int.TryParse(pobs.Value.ToString(), out var pmeset) ? pmeset : 0
                : targetValue;

            var drivingPressureObs = new PatientObservation
            {
                PatientId = obs.PatientId,
                Time = DateTime.UtcNow,
                CodingSystem = CodingSystem,
                Name = "Driving_Pressure",
                Value = pmesetValue - peepValue
            };

            await _observationService.Value.InsertObservation(drivingPressureObs, mapObs: false);
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
    }

    private async Task CalculateOverAnalgesia(BasePatientObservation? obs, ObjectId? patientId = null)
    {
        // Mandar observación 'SOBREANALGESIA'
        // 0 <= EVN <= 3 o ESCID = 3 o ANI > 70
        // y
        // Perfusiones de morfina, remifentanilo y fentanilo sostenidas > 24h.

        try
        {
            List<string> requiredObservations = ["EVN", "ESCID", "ANI"];

            // Si patientId es null, la información proviene de una observación.
            // Si tiene valor, proviene de un tratamiento.
            if (!patientId.HasValue)
            {
                if (obs is not PatientObservation pobs || !int.TryParse(pobs.Value.ToString(), out _))
                    return;

                patientId = pobs.PatientId;
            }

            var observations =
                await _observationService.Value.FindLastObservations(patientId.Value, 1, requiredObservations);

            // Verificar si alguna observación cumple la condición
            var condition1 = observations.Any(observation =>
                int.TryParse(observation.Value.ToString(), out var obsValue) && observation.Name switch
                {
                    "EVN" when obsValue is >= 0 and <= 3 => true,
                    "ESCID" when obsValue == 3 => true,
                    "ANI" when obsValue > 70 => true,
                    _ => false
                });

            if (!condition1)
                return;

            // Verificar tratamientos activos y umbral de analgesia
            var treatments = await _treatmentService.Value.GetActiveTreatmentsByPatient(patientId.Value);
            var patientTreatments = treatments.ToList();
            if (!patientTreatments.Any()) return;

            var morfina =
                patientTreatments.FirstOrDefault(t => t != null && t.RequestedGiveCodes.Any(c => c.Text is "Morfina"));
            var remifentanilo = patientTreatments.FirstOrDefault(t =>
                t != null && t.RequestedGiveCodes.Any(c => c.Text is "Remifentanilo"));
            var fentanilo =
                patientTreatments.FirstOrDefault(t =>
                    t != null && t.RequestedGiveCodes.Any(c => c.Text is "Fentanilo"));

            if (morfina != null && !ExceedsAnalgesiaThreshold(morfina) &&
                remifentanilo != null && !ExceedsAnalgesiaThreshold(remifentanilo) &&
                fentanilo != null && !ExceedsAnalgesiaThreshold(fentanilo))
                return;


            var overAnalgesiaObs = new PatientObservation
            {
                PatientId = patientId.Value,
                Time = DateTime.UtcNow,
                CodingSystem = CodingSystem,
                Name = "Over_Analgesia",
                Value = bool.TrueString
            };

            await _observationService.Value.InsertObservation(overAnalgesiaObs, mapObs: false);
        }
        catch (Exception ex)
        {
            _logger.LogError("Error calculating Over_Analgesia. Exception: {ex}", ex);
            throw;
        }
    }

    private Task<BasePatientObservation> CalculateEcmoLocation(BasePatientObservation obs)
    {
        //Las opciones pueden ser VV, VA o ECMO.
        //Cuando llegue VV se muestra VV.
        //Cuando llegue VA se muestra VA.
        //Cuando llegue los siguientes parámetros, se debe mostrar ECMO: ECCO2r, VVDL, VA+V, VVDL+V, VV+V, VVA
        if (obs is not PatientObservation pobs)
            return Task.FromResult(obs);

        var ecmoValues = new List<string> { "ECCO2r", "VVDL", "VA+V", "VVDL+V", "VV+V", "VVA" };

        var obsValue = pobs.Value.ToString();

        if (obsValue != null && ecmoValues.Contains(obsValue)) pobs.Value = "ECMO";

        return Task.FromResult(obs);
    }

    private async Task CalculateVentilationMode(BasePatientObservation obs)
    {
        //- Si llega valor de PI pero NO COMPL, el tipo de ventilación es VMNI
        //- Si llega valor de PS pero no llega COMPL, el tipo de ventilación es VMNI
        //- Si llega COMPL, el tipo de ventilación es VMI
        //- Si llega Flujo, leer el tipo de ventilación de CCC(CNAF o CTAF)

        var mode = string.Empty;

        switch (obs.Name)
        {
            case "Inspiratory_Pressure":
                var complObs = await _observationService.Value.FindLastObservations(obs.PatientId, 1, ["Compliancia"]);
                if (!complObs.Any())
                    mode = "VMNI";

                break;
            case "Compliancia":
                mode = "VMI";
                break;
            case "Air_Flow":
                var cccVentMode =
                    await _observationService.Value.FindByPatientIdAndCodingSystemAsync(obs.PatientId, "CCC",
                        "Ventilation_Mode");

                if (!await cccVentMode.AnyAsync())
                    return;
                mode = cccVentMode.First().Value.ToString() ?? string.Empty;
                break;
            default:
                return;
        }

        if (string.IsNullOrEmpty(mode)) return;


        var ventilationModeObservation = new PatientObservation
        {
            PatientId = obs.PatientId,
            Time = DateTime.UtcNow,
            CodingSystem = CodingSystem,
            Name = "Ventilation_Mode",
            Value = mode
        };

        _ = _observationService.Value.InsertObservation(ventilationModeObservation, mapObs: false);
    }

    private async Task CalculateOverSedation(BasePatientObservation? obs, ObjectId? patientId = null)
    {
        //Mandar observación 'SOBRESEDACIÓN'
        //cuando:
        //(RASS =-4 o RASS =-5) y
        //PSI < 25 y
        //TS > 5 y
        //(Propofol > 3 o Midazolam > 0,05 ó Isoflorano > 10)

        try
        {
            var pobsName = string.Empty;

            //si patientId viene null viene la observación
            //Si tiene valor viene de un tratamiento

            if (!patientId.HasValue)
            {
                if (obs is not PatientObservation pobs || !int.TryParse(pobs.Value.ToString(), out var pobsValue))
                    return;

                patientId = pobs.PatientId;
                pobsName = pobs.Name;

                switch (pobsName)
                {
                    case "RASS" when pobsValue is not (-4 or -5):
                    case "PSI" when pobsValue >= 25:
                    case "TS" when pobsValue <= 5:
                        return;
                }
            }


            var requiredObservations = pobsName switch
            {
                "RASS" => ["PSI", "TS"],
                "PSI" => ["RASS", "TS"],
                "TS" => ["RASS", "PSI"],
                _ => new List<string> { "RASS", "PSI", "TS" }
            };

            var result = await _observationService.Value.FindLastObservations(patientId.Value, 1, requiredObservations);
            var observations = result.ToDictionary(r => r.Name?.ToString() ?? "null");

            if ((pobsName != "RASS" && (!observations.TryGetValue("RASS", out var rassObs) ||
                                        !int.TryParse(rassObs.Value.ToString(), out var rassValue) ||
                                        rassValue is not (-4 or -5))) ||
                (pobsName != "PSI" && (!observations.TryGetValue("PSI", out var psiObs) ||
                                       !int.TryParse(psiObs.Value.ToString(), out var psiValue) || psiValue >= 25)) ||
                (pobsName != "TS" && (!observations.TryGetValue("TS", out var tsObs) ||
                                      !int.TryParse(tsObs.Value.ToString(), out var tsValue) || tsValue <= 5)))
                return;

            var treatments = await _treatmentService.Value.GetActiveTreatmentsByPatient(patientId.Value);
            if (!treatments.Any(ExceedsSedationThreshold)) return;

            var overSedationObs = new PatientObservation
            {
                PatientId = patientId.Value,
                Time = DateTime.UtcNow,
                CodingSystem = CodingSystem,
                Name = "Over_Sedation",
                Value = bool.TrueString
            };

            await _observationService.Value.InsertObservation(overSedationObs, mapObs: false);
        }
        catch (Exception ex)
        {
            _logger.LogError("Error calculating Over_Sedation. Exception: {ex}", ex);
            throw;
        }
    }

    private static bool ExceedsAnalgesiaThreshold(PatientTreatment? treatment)
    {
        // Perfusiones de morfina, remifentanilo o fentanilo sostenidas > 24 h

        return treatment is { StartTime: not null } &&
               treatment.StartTime.Value.AddSeconds(86400) < DateTime.UtcNow;
    }

    private static bool ExceedsSedationThreshold(PatientTreatment? treatment)
    {
        return (treatment != null &&
                treatment.RequestedGiveCodes.Any(c =>
                    c.Text == "Propofol" && treatment.RequestedGiveAmountMinimum > 3)) ||
               (treatment != null && treatment.RequestedGiveCodes.Any(c =>
                   c.Text == "Midazolam" && treatment.RequestedGiveAmountMinimum > 0.05)) ||
               (treatment != null && treatment.RequestedGiveCodes.Any(c =>
                   c.Text == "Isoflorano" && treatment.RequestedGiveAmountMinimum > 10));
    }

    private async Task<List<PatientTreatment>> CheckExpiredPatientTreatments(PatientTreatment treatment)
    {
        //si el tratamiento ha expirado actualizamos el OrderControl a DC y devolvemos las que siguen activas
        var result = new List<PatientTreatment>();
        var oldTreatments = await _treatmentService.Value.GetActiveTreatmentsByPatient(treatment.PatientId);

        foreach (var t in oldTreatments.Where(t => t != null))
            if (t is { EndTime: not null } && t.EndTime > DateTime.UtcNow)
            {
                t.OrderControl = OrderControlType.Dc;
                _ = _treatmentService.Value.UpdateTreatment(t);
            }
            else if (t != null)
            {
                result.Add(t);
            }


        return result;
    }

    private async Task CheckTreatmentMedicines(PatientTreatment treatment)
    {
        var newMedicines = (await Task.WhenAll(treatment.RequestedGiveCodes
                .Select(async code => await _medicineService.Value.GetByCode(code.Identifier))))
            .Where(m => m != null)
            .ToList();

        if (newMedicines.Count == 0) return;

        var activeTreatments = (await GetActiveTreatmentsByPatient(treatment.PatientId)).ToList();
        var activeMedicines = (await _medicineService.Value.GetMedicinesOfTreatments(activeTreatments)).ToList();

        // Combina ambas listas y selecciona solo elementos únicos con el mismo nombre
        var uniqueMedicines = newMedicines
            .Concat(activeMedicines)
            .GroupBy(m => m?.Name)
            .Select(g => g.First())
            .ToList();

        // uniqueMedicines contiene la lista de medicamentos activos de un paciente
        CheckMedicationCategories(treatment.PatientId, uniqueMedicines as List<Medicine>);
    }

    private void CheckMedicationCategories(ObjectId patientId, List<Medicine> uniqueMedicines)
    {
        var medicationCategories = new Dictionary<string, List<string>?>
        {
            { "Sedation_Medication_Multivalue", _sedationList },
            { "Inotropic_Medication_Multivalue", _inotropicMedicines },
            { "Antibiotic_Medication_Multivalue", _antibioticList },
            { "Anxiolytic_Medication_Multivalue", _anxiolyticsList },
            { "Antipsychotic_Medication_Multivalue", _antipsicoticList },
            { "Antidepressants_Medication_Multivalue", _antidepressantsList },
            { "Neuro_Medication_Multivalue", _neuroMedicationList },
            { "Crystalloid_Serum_Medication_Multivalue", _serumCrystalloidList },
            { "Colloid_Serum_Medication_Multivalue", _serumColloidList },
            { "Antihypertensives_Medication_Multivalue", _antihypertensivesList }
        };

        foreach (var category in medicationCategories)
        {
            var observations = uniqueMedicines?
                .Where(m => category.Value != null && !string.IsNullOrEmpty(m.Name) && m.Name != null &&
                            category.Value.Contains(m.Name))
                .ToList();

            if (observations != null && observations.Any())
                _ = CreateMedicationMultivalueObservation(observations, patientId, category.Key);
        }
    }


    private async Task CreateMedicationMultivalueObservation(IEnumerable<Medicine?> medications, ObjectId patientId,
        string obsName)
    {
        var newObs = new PatientObservation
        {
            PatientId = patientId,
            Name = obsName,
            CodingSystem = CodingSystem,
            Value = medications.Select(m => m?.Name).ToArray(),
            Time = DateTime.Now
        };

        var lastObsList = await _observationService.Value.FindLastObservations(patientId, 1, [obsName]);
        var lastObs = lastObsList.FirstOrDefault();
        if (lastObs is { Expired: false })
        {
            //expiramos la anterior
            lastObs.Expired = true;
            _ = _observationService.Value.UpdateObservation(lastObs);
        }

        await _observationService.Value.InsertObservation(newObs,
            mapObs: false); //mapObs:no volvemos a mapear la observación
    }
}