using adas_core.Domain.Enums;
using adas_core.Domain.Models;
using adas_core.Domain.Models.MongoModels;
using adas_core.Domain.Models.SystemAlerts;
using adas_core.Infrastructure.Utils.MongoMaps.Interfaz;
using MongoDB.Bson;
using MongoDB.Bson.Serialization;
using MongoDB.Bson.Serialization.Serializers;

namespace adas_core.Infrastructure.Utils.MongoMaps;

public class AlarmMapContributor : IEntityMapContributor
{
    public void RegisterMaps()
    {
        if (!BsonClassMap.IsClassMapRegistered(typeof(AlarmConfig)))
            BsonClassMap.RegisterClassMap<AlarmConfig>(cm =>
            {
                cm.AutoMap();
                cm.MapMember(c => c.Name).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Enabled).SetDefaultValue(false);
                cm.MapMember(c => c.EndAfter).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Recording).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Beacon).SetIgnoreIfNull(true);
                cm.MapMember(c => c.OpenDoor).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Priority).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Color).SetIgnoreIfNull(true);
                cm.MapMember(c => c.AudioConfig).SetIgnoreIfNull(true);
            });

        if (!BsonClassMap.IsClassMapRegistered(typeof(AudioConfig)))
            BsonClassMap.RegisterClassMap<AudioConfig>(cm =>
            {
                cm.AutoMap();
                cm.MapMember(c => c.Type)
                    .SetDefaultValue(AlarmEnum.AudioAlarmType.Off)
                    .SetSerializer(new EnumSerializer<AlarmEnum.AudioAlarmType>(BsonType.String));
                cm.MapMember(c => c.Path).SetIgnoreIfNull(true);
                cm.MapMember(c => c.EndAfter).SetIgnoreIfNull(true);
            });

        if (!BsonClassMap.IsClassMapRegistered(typeof(AlarmItem)))
            BsonClassMap.RegisterClassMap<AlarmItem>(cm =>
            {
                cm.AutoMap();
                cm.MapMember(c => c.Enabled).SetDefaultValue(false);
                cm.MapMember(c => c.StartBefore).SetIgnoreIfNull(true);
                cm.MapMember(c => c.EndAfter).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Color).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Severity)
                    .SetDefaultValue(AlarmEnum.Severity.None)
                    .SetSerializer(new EnumSerializer<AlarmEnum.Severity>(BsonType.String));
                cm.MapMember(c => c.BeaconColor)
                    .SetDefaultValue(AlarmEnum.BeaconColor.None)
                    .SetSerializer(new EnumSerializer<AlarmEnum.BeaconColor>(BsonType.String));
            });

        if (!BsonClassMap.IsClassMapRegistered(typeof(PatientObservationAlarm)))
        {
            BsonClassMap.RegisterClassMap<PatientObservationAlarm>(cm =>
            {
                cm.AutoMap();
                cm.MapMember(c => c.InactivationState).SetIgnoreIfNull(true);
                cm.MapMember(c => c.EventPhase)
                    .SetDefaultValue(AlarmEnum.EventPhase.Continue)
                    .SetSerializer(new EnumSerializer<AlarmEnum.EventPhase>(BsonType.String));
                cm.MapMember(c => c.Event).SetIgnoreIfNull(true);
                cm.MapMember(c => c.EventId).SetIgnoreIfNull(true);
                cm.MapMember(c => c.State)
                    .SetIgnoreIfNull(true)
                    .SetSerializer(new NullableSerializer<AlarmEnum.ObservationAlarmState>(
                        new EnumSerializer<AlarmEnum.ObservationAlarmState>(BsonType.String)));
                cm.MapMember(c => c.Priority)
                    .SetIgnoreIfNull(true)
                    .SetSerializer(new NullableSerializer<AlarmEnum.ObservationAlarmPriority>(
                        new EnumSerializer<AlarmEnum.ObservationAlarmPriority>(BsonType.String)));
                cm.MapMember(c => c.PriorityLevel)
                    .SetIgnoreIfNull(true)
                    .SetSerializer(new NullableSerializer<int>(new Int32Serializer()));
                cm.UnmapMember(c => c.AlarmConfig);
                cm.MapMember(c => c.Type)
                    .SetIgnoreIfNull(true)
                    .SetSerializer(
                        new NullableSerializer<AlarmEnum.ObservationAlarmType>(
                            new EnumSerializer<AlarmEnum.ObservationAlarmType>(BsonType.String)));
                cm.MapMember(c => c.AlertColor).SetIgnoreIfNull(true)
                    .SetSerializer(new StringSerializer(BsonType.String));
                cm.UnmapMember(c => c.MessageTime);
                cm.MapMember(c => c.Persist).SetIgnoreIfNull(true);
                cm.UnmapMember(c => c.Expired);
                cm.MapMember(c => c.Expires).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Sources).SetIgnoreIfNull(true);
            });

            BsonClassMap.RegisterClassMap<InactivationState>(cm =>
            {
                cm.AutoMap();
                cm.MapMember(c => c.Audio)
                    .SetIgnoreIfNull(true)
                    .SetSerializer(
                        new NullableSerializer<AlarmEnum.AudioVideoState>(
                            new EnumSerializer<AlarmEnum.AudioVideoState>(BsonType.String)));
                cm.MapMember(c => c.Visual)
                    .SetIgnoreIfNull(true)
                    .SetSerializer(
                        new NullableSerializer<AlarmEnum.AudioVideoState>(
                            new EnumSerializer<AlarmEnum.AudioVideoState>(BsonType.String)));
                cm.MapMember(c => c.Acknowledge).SetIgnoreIfNull(true);
            });

            BsonClassMap.RegisterClassMap<Source>(cm =>
            {
                cm.AutoMap();
                cm.MapMember(c => c.Code).SetIgnoreIfNull(true);
                cm.MapMember(c => c.OriginalName).SetIgnoreIfNull(true);
                cm.MapMember(c => c.CodeSystem).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Units).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Value).SetIgnoreIfNull(true);
                cm.MapMember(c => c.Result).SetIgnoreIfNull(true);
            });
        }

        if (!BsonClassMap.IsClassMapRegistered(typeof(PatientRecordingAlert)))
            BsonClassMap.RegisterClassMap<PatientRecordingAlert>(cm =>
            {
                cm.AutoMap();
                cm.MapMember(c => c.IsRecording);
            });

        if (!BsonClassMap.IsClassMapRegistered(typeof(Performance)))
            BsonClassMap.RegisterClassMap<Performance>(cm => { cm.AutoMap(); });
    }
}