using DTS.Common.Base;
using DTS.Common.Enums;
using DTS.Common.Interface.Sensors;
using DTS.Common.Utilities.Logging;
using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data;
using System.Linq;

namespace DTS.Common.Classes.Sensors
{
    public class SquibDbRecord : BasePropertyChanged, ISquibDbRecord
    {
        private string _serialNumber = "";
        public string SerialNumber
        {
            get => _serialNumber;
            set => SetProperty(ref _serialNumber, value, "SerialNumber");
        }
        private int _id = -1;
        [Key]
        public int Id
        {
            get => _id;
            set => SetProperty(ref _id, value, "Id");
        }
        private bool _bypassCurrentFilter = false;
        public bool BypassCurrentFilter
        {
            get => _bypassCurrentFilter;
            set => SetProperty(ref _bypassCurrentFilter, value, "BypassCurrentFilter");
        }
        private bool _bypassVoltageFilter = false;
        public bool BypassVoltageFilter
        {
            get => _bypassVoltageFilter;
            set => SetProperty(ref _bypassVoltageFilter, value, "BypassVoltageFilter");
        }
        private double _delayMS = 0D;
        [Column("DelayMS")]
        public double DelayMs
        {
            get => _delayMS;
            set => SetProperty(ref _delayMS, value, "DelayMs");
        }
        private double _durationMS = 10D;
        [Column("DurationMS")]
        public double DurationMs
        {
            get => _durationMS;
            set => SetProperty(ref _durationMS, value, "DurationMs");
        }
        private SquibFireMode _fireMode = SquibFireMode.NONE;
        public SquibFireMode FireMode
        {
            get => _fireMode;
            set => SetProperty(ref _fireMode, value, "FireMode");
        }
        private string _isoCode = "";
        [Required]
        [StringLength(50)]
        public string IsoCode
        {
            get => _isoCode;
            set => SetProperty(ref _isoCode, value, "IsoCode");
        }
        private string _isoChannelName = "";
        [Required]
        [StringLength(255)]
        public string IsoChannelName
        {
            get => _isoChannelName;
            set => SetProperty(ref _isoChannelName, value, "IsoChannelName");
        }
        private string _userCode = "";
        [Required]
        [StringLength(50)]
        public string UserCode
        {
            get => _userCode;
            set => SetProperty(ref _userCode, value, "UserCode");
        }
        private string _userChannelName = "";
        [Required]
        [StringLength(255)]
        public string UserChannelName
        {
            get => _userChannelName;
            set => SetProperty(ref _userChannelName, value, "UserChannelName");
        }
        private SquibMeasurementType _squibMeasurementType = SquibMeasurementType.VOLTAGE;
        public SquibMeasurementType MeasurementType
        {
            get => _squibMeasurementType;
            set => SetProperty(ref _squibMeasurementType, value, "MeasurementType");
        }
        private double _squibOutputCurrent = 1.5D;
        public double SquibOutputCurrent
        {
            get => _squibOutputCurrent;
            set => SetProperty(ref _squibOutputCurrent, value, "SquibOutputCurrent");
        }
        private double _squibToleranceLow = 1D;
        public double SquibToleranceLow
        {
            get => _squibToleranceLow;
            set => SetProperty(ref _squibToleranceLow, value, "SquibToleranceLow");
        }
        private double _squibToleranceHigh = 8D;
        public double SquibToleranceHigh
        {
            get => _squibToleranceHigh;
            set => SetProperty(ref _squibToleranceHigh, value, "SquibToleranceHigh");
        }
        private bool _limitDuration = true;
        public bool LimitDuration
        {
            get => _limitDuration;
            set => SetProperty(ref _limitDuration, value, "LimitDuration");
        }
        private string _articleId = "";
        [Required]
        [StringLength(50)]
        public string ArticleId
        {
            get => _articleId;
            set => SetProperty(ref _articleId, value, "ArticleId");
        }
        private int _version = 1;
        public int Version
        {
            get => _version;
            set => SetProperty(ref _version, value, "Version");
        }
        private DateTime _lastModified = DateTime.MinValue;
        [Column(TypeName = "datetime")]
        public DateTime LastModified
        {
            get => _lastModified;
            set => SetProperty(ref _lastModified, value, "LastModified");
        }
        private string _lastModifiedBy = "";
        [Required]
        [StringLength(50)]
        public string LastModifiedBy
        {
            get => _lastModifiedBy;
            set => SetProperty(ref _lastModifiedBy, value, "LastModifiedBy");
        }
        private string _userValue1 = "";
        [StringLength(255)]
        public string UserValue1
        {
            get => _userValue1;
            set => SetProperty(ref _userValue1, value, "UserValue1");
        }
        private string _userValue2 = "";
        [StringLength(255)]
        public string UserValue2
        {
            get => _userValue2;
            set => SetProperty(ref _userValue2, value, "UserValue2");
        }
        private string _userValue3 = "";
        [StringLength(255)]
        public string UserValue3
        {
            get => _userValue3;
            set => SetProperty(ref _userValue3, value, "UserValue3");
        }
        private byte[] _userTags = new byte[0];
        public byte[] UserTags
        {
            get => _userTags;
            set => SetProperty(ref _userTags, value, "UserTags");
        }
        private bool _doNotUse = false;
        public bool DoNotUse
        {
            get => _doNotUse;
            set => SetProperty(ref _doNotUse, value, "DoNotUse");
        }
        private bool _broken = false;
        public bool Broken
        {
            get => _broken;
            set => SetProperty(ref _broken, value, "Broken");
        }
        private bool _defineDelayInTest = false;
        public bool DefineDelayInTest
        {
            get => _defineDelayInTest;
            set => SetProperty(ref _defineDelayInTest, value, "DefineDelayInTest");
        }
        public SquibDbRecord(ISensorData copy, bool defineDelayInTest, byte[] tags)
        {
            Id = copy.DatabaseId;
            IsoChannelName = copy.ISOChannelName;
            UserCode = copy.UserCode;
            UserChannelName = copy.UserChannelName;
            Broken = copy.Broken;
            DoNotUse = copy.DoNotUse;
            Version = copy.Version;
            SquibToleranceLow = copy.SquibToleranceLow;
            SquibToleranceHigh = copy.SquibToleranceHigh;
            SquibOutputCurrent = copy.SquibOutputCurrent;
            SerialNumber = copy.SerialNumber;
            MeasurementType = copy.SquibMeasurementType;
            LimitDuration = copy.LimitDuration;
            DefineDelayInTest = defineDelayInTest;
            LastModifiedBy = copy.LastUpdatedBy;
            LastModified = copy.LastModified;
            IsoCode = copy.ISOCode;
            FireMode = copy.SquibFireMode;
            DurationMs = copy.SquibFireDurationMS;
            DelayMs = copy.SquibFireDelayMS;
            BypassVoltageFilter = copy.BypassVoltageFilter;
            BypassCurrentFilter = copy.BypassCurrentFilter;
            ArticleId = copy.EID;
            UserValue1 = copy.UserValue1;

            UserValue2 = copy.UserValue2;
            UserValue3 = copy.UserValue3;
            if (null == tags) { UserTags = null; }
            else if (tags.Any())
            {
                var userTags = new byte[tags.Length];
                Array.Copy(tags, userTags, tags.Length);
                UserTags = userTags;
            }
            else { UserTags = new byte[0]; }
        }
        public SquibDbRecord() { }
        public SquibDbRecord(ISquibDbRecord copy)
        {
            Id = copy.Id;
            IsoChannelName = copy.IsoChannelName;
            UserCode = copy.UserCode;
            UserChannelName = copy.UserChannelName;
            Broken = copy.Broken;
            DoNotUse = copy.DoNotUse;
            Version = copy.Version;
            SquibToleranceLow = copy.SquibToleranceLow;
            SquibToleranceHigh = copy.SquibToleranceHigh;
            SquibOutputCurrent = copy.SquibOutputCurrent;
            SerialNumber = copy.SerialNumber;
            MeasurementType = copy.MeasurementType;
            LimitDuration = copy.LimitDuration;
            DefineDelayInTest = copy.DefineDelayInTest;
            LastModifiedBy = copy.LastModifiedBy;
            LastModified = copy.LastModified;
            IsoCode = copy.IsoCode;
            FireMode = copy.FireMode;
            DurationMs = copy.DurationMs;
            DelayMs = copy.DelayMs;
            BypassVoltageFilter = copy.BypassVoltageFilter;
            BypassCurrentFilter = copy.BypassCurrentFilter;
            ArticleId = copy.ArticleId;
            UserValue1 = copy.UserValue1;
            //Comment = UserValue1;
            UserValue2 = copy.UserValue2;
            UserValue3 = copy.UserValue3;
            if (null == copy.UserTags) { UserTags = null; }
            else if (copy.UserTags.Any())
            {
                var userTags = new byte[copy.UserTags.Length];
                Array.Copy(copy.UserTags, userTags, copy.UserTags.Length);
                UserTags = userTags;
            }
            else { UserTags = new byte[0]; }
        }
        public SquibDbRecord(IDataReader reader)
        {
            try
            {
                Id = Utility.GetInt(reader, "Id", -1);
                IsoChannelName = Utility.GetString(reader, "ISOChannelName", string.Empty);
                UserCode = Utility.GetString(reader, "UserCode", string.Empty);
                UserChannelName = Utility.GetString(reader, "UserChannelName", string.Empty);
                Broken = Utility.GetBool(reader, "Broken", false);
                DoNotUse = Utility.GetBool(reader, "DoNotUse", false);
                Version = Utility.GetInt(reader, "Version", -1);
                SquibToleranceLow = Utility.GetDouble(reader, "SquibToleranceLow", 0D);
                SquibToleranceHigh = Utility.GetDouble(reader, "SquibToleranceHigh", 8D);
                SquibOutputCurrent = Utility.GetDouble(reader, "SquibOutputCurrent", 1.5D);
                SerialNumber = Utility.GetString(reader, "SerialNumber", string.Empty);
                MeasurementType = (SquibMeasurementType)Utility.GetShort(reader, "MeasurementType");
                LimitDuration = Utility.GetBool(reader, "LimitDuration");
                DefineDelayInTest = Utility.GetBool(reader, "DefineDelayInTest");
                LastModifiedBy = Utility.GetString(reader, "LastModifiedBy", string.Empty);
                LastModified = Utility.GetDateTime(reader, "LastModified", DateTime.MinValue);
                IsoCode = Utility.GetString(reader, "ISOCode", string.Empty);
                FireMode = (SquibFireMode)Utility.GetShort(reader, "FireMode");
                DurationMs = Utility.GetDouble(reader, "DurationMS", 0D);
                DelayMs = Utility.GetDouble(reader, "DelayMS", 0D);
                BypassVoltageFilter = Utility.GetBool(reader, "BypassVoltageFilter", false);
                BypassCurrentFilter = Utility.GetBool(reader, "BypassCurrentFilter", false);
                ArticleId = Utility.GetString(reader, "ArticleId", string.Empty);
                UserValue1 = Utility.GetString(reader, "UserValue1");
                //Comment = UserValue1;
                UserValue2 = Utility.GetString(reader, "UserValue2", string.Empty);
                UserValue3 = Utility.GetString(reader, "UserValue3", string.Empty);
                var o = reader["UserTags"];
                UserTags = DBNull.Value.Equals(o)
                    ? new byte[0]
                    : (byte[])o;

            }
            catch (Exception ex)
            {
                APILogger.Log("Failed to process: ", ex);
            }
        }
    }
}