using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

namespace DatabaseExport
{
    public class TestObject : DbTimeStampBase, IComparable<TestObject>
    {
        public override string LookupTable => DbOperations.TestSetups.TestObjectsTable;

        public override ConstraintHelper[] GetConstraints()
        {
            return new[]
            {
                        new ConstraintHelper
                        {
                            ColumnName = DbOperations.TestSetups.TestObjectsFields.SerialNumber.ToString(),
                            DbType = System.Data.SqlDbType.NVarChar,
                            DbValue = SerialNumber
                        }
            };
        }
        public void RefreshHardware()
        {
            SetHardwareFromISO();
        }
        public enum Tags
        {
            SerialNumber,
            SerialNumberConverted,
            TestObjectType,
            ParentObject,
            SysBuilt,
            Channels,
            Hardware,
            LastModifiedBy,
            LastModifiedText,
            AllTemplates,
            Template,
            TemplateIndex,
            ChannelsDescription,
            TemplateDescription,
            TemplateImage,
            Zones,
            SelectedGlobalRangeCACOption,
            ZoneNames,
            CurrentZone,
            CurrentZoneIndex,
            ChannelVisibility,
            ChannelTypesIndex
        }

        /// <summary>
        /// dirty controls whether _isComplete is valid or not
        /// if Dirty is true then _isComplete is not valid
        /// IsComplete will actually calculate this value
        /// </summary>
        public bool IsDirty { get; set; } = true;

        public int CompareTo(TestObject rhs)
        {
            if (null == rhs) { return 1; }
            return rhs == this ? 0 : SerialNumber.CompareTo(rhs.SerialNumber);
        }
        /// <summary>
        /// returns the iso support level of the group
        /// </summary>
        /// <returns></returns>
        public SerializedSettings.ISOSupportLevels GetObjectISOLevel()
        {
            if (TemplateType.Contains(TestObjectTemplate.NON_ISO_TESTOBJECT_CHANNEL_TYPE) || TemplateType.Contains(TestObjectTemplateChannel.NONISOCHANNELTYPE))
            {
                return SerializedSettings.ISOSupportLevels.NO_ISO;
            }
            return SerializedSettings.ISOSupportLevels.ISO_ONLY;
        }
        public SensorData GetSensor(string ChannelId, string serialNumber)
        {
            var sd = SensorsCollection.SensorsList.GetSensorBySerialNumber(serialNumber);

            if (null == sd) { return null; }
            sd = new SensorData(sd);
            var settings = GetISOTestObject().GetSensorSettings(ChannelId, sd.SerialNumber);
            var isoTO = GetISOTestObject();
            var channel = isoTO.GetChannel(ChannelId);
            if (null != channel)
            {
                //preset the channel iso fields, these can be filter can be overwritten by to settings below
                sd.TestObject = channel.Channel.Test_Object;
                sd.Position = channel.Channel.Position;
                sd.OriginalPosition = channel.Channel.Position;
                if (channel.Channel.Default_Filter_Class != "?")
                {
                    //If ISO says "?", then use the sensor's filter class (but still overwrite with any settings below)
                    sd.FilterClassIso = channel.Channel.Default_Filter_Class;
                }
                sd.FineLocation1 = channel.Channel.Fine_Loc_1;
                sd.FineLocation2 = channel.Channel.Fine_Loc_2;
                sd.FineLocation3 = channel.Channel.Fine_Loc_3;
                sd.MainLocation = channel.Channel.Trans_Main_Loc;
                sd.PhysicalDimension = channel.Channel.Physical_Dimension;
                sd.Direction = channel.Channel.Direction;
            }
            if (null != settings)
            {
                foreach (var setting in settings)
                {
                    switch (setting.Setting)
                    {
                        case ISO.TestObject.SensorSettings.CFC:
                            sd.FilterClassIso = setting.Value;
                            switch (sd.FilterClassIso)
                            {
                                case "A":
                                    sd.Filter = new FilterClass(FilterClass.FilterClassType.CFC1000);
                                    break;
                                case "B":
                                    sd.Filter = new FilterClass(FilterClass.FilterClassType.CFC600);
                                    break;
                                case "C":
                                    sd.Filter = new FilterClass(FilterClass.FilterClassType.CFC180);
                                    break;
                                case "D":
                                    sd.Filter = new FilterClass(FilterClass.FilterClassType.CFC60);
                                    break;
                                case "P":
                                    sd.Filter = new FilterClass(FilterClass.FilterClassType.None);
                                    break;
                                case "S":
                                    //FB 13120 Adhoc filter class
                                    sd.Filter = new FilterClass(FilterClass.FilterClassType.AdHoc);
                                    break;
                            }
                            break;
                        case ISO.TestObject.SensorSettings.Position:
                            sd.Position = setting.Value;
                            break;
                        case ISO.TestObject.SensorSettings.Polarity:
                            sd.Invert = setting.Value == "-";
                            break;
                        case ISO.TestObject.SensorSettings.Range:
                            sd.Capacity = double.Parse(setting.Value, CultureInfo.InvariantCulture);
                            break;
                        case ISO.TestObject.SensorSettings.LimitDuration:
                            if (!string.IsNullOrWhiteSpace(setting.Value))
                            {
                                sd.DigitalOutputLimitDuration = bool.Parse(setting.Value);
                                sd.LimitDuration = bool.Parse(setting.Value);
                                sd.LimitSquibFireDuration = bool.Parse(setting.Value);
                            }
                            break;
                        case ISO.TestObject.SensorSettings.Delay:
                            if (!string.IsNullOrWhiteSpace(setting.Value))
                            {
                                sd.DigitalOutputDelayMS = double.Parse(setting.Value, CultureInfo.InvariantCulture);
                                sd.DelayMS = double.Parse(setting.Value, CultureInfo.InvariantCulture);
                                sd.SquibFireDelayMS = double.Parse(setting.Value, CultureInfo.InvariantCulture);
                            }
                            break;
                        case ISO.TestObject.SensorSettings.Duration:
                            if (!string.IsNullOrWhiteSpace(setting.Value))
                            {
                                sd.DigitalOutputDurationMS = double.Parse(setting.Value, CultureInfo.InvariantCulture);
                                sd.DurationMS = double.Parse(setting.Value, CultureInfo.InvariantCulture);
                                sd.SquibFireDurationMS = double.Parse(setting.Value, CultureInfo.InvariantCulture);
                            }
                            break;

                        case ISO.TestObject.SensorSettings.OutputMode:
                            if (!string.IsNullOrWhiteSpace(setting.Value))
                            {
                                int iValue;
                                if (int.TryParse(setting.Value, NumberStyles.Any, CultureInfo.InvariantCulture,
                                    out iValue))
                                {
                                    sd.DigitalOutputMode = (OutputTOMDigitalChannel.DigitalOutputMode)iValue;
                                }
                            }
                            break;
                        case ISO.TestObject.SensorSettings.SQMode:
                            if (!string.IsNullOrWhiteSpace(setting.Value))
                            {
                                int iValue;
                                if (int.TryParse(setting.Value, NumberStyles.Any, CultureInfo.InvariantCulture,
                                    out iValue))
                                {
                                    sd.SquibFireMode = (OutputSquibChannel.SquibFireMode)iValue;
                                }
                            }
                            break;
                        case ISO.TestObject.SensorSettings.DIMode:
                            if (!string.IsNullOrWhiteSpace(setting.Value))
                            {
                                int iValue;
                                if (int.TryParse(setting.Value, NumberStyles.Any, CultureInfo.InvariantCulture,
                                    out iValue))
                                {
                                    sd.InputMode = (DigitalInputScaleMultiplier.InputModes)iValue;
                                }
                            }
                            break;
                        case ISO.TestObject.SensorSettings.DefaultValue:
                            if (!string.IsNullOrWhiteSpace(setting.Value))
                            {
                                if (double.TryParse(setting.Value, out var defaultValue))
                                {
                                    sd.ScaleMultiplier.DefaultValue = defaultValue;
                                }
                            }
                            break;
                        case ISO.TestObject.SensorSettings.ActiveValue:
                            if (!string.IsNullOrWhiteSpace(setting.Value))
                            {
                                if (double.TryParse(setting.Value, out var activeValue))
                                {
                                    sd.ScaleMultiplier.ActiveValue = activeValue;
                                }
                            }
                            break;
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
            }
            if (sd.FilterClassIso == "?")
            {
                sd.FilterClassIso = "P"; // "Prefiltered > CFC 1000" (Unfiltered)
            }
            return sd;
        }

        public void SetSensor(string channelName, SensorData sensor)
        {
            var settings = new List<ISO.TestObject.SensorSetting>();
            var fields = Enum.GetValues(typeof(ISO.TestObject.SensorSettings)).Cast<ISO.TestObject.SensorSettings>().ToArray();
            foreach (var field in fields)
            {
                var value = "";
                switch (field)
                {
                    case ISO.TestObject.SensorSettings.CFC:
                        value = sensor.FilterClassIso;
                        break;
                    case ISO.TestObject.SensorSettings.Position:
                        value = sensor.Position;
                        break;
                    case ISO.TestObject.SensorSettings.Polarity:
                        value = sensor.Invert ? "-" : "+";
                        break;
                    case ISO.TestObject.SensorSettings.Range:
                        value = sensor.Capacity.ToString(CultureInfo.InvariantCulture);
                        break;
                    case ISO.TestObject.SensorSettings.Duration:
                        value = sensor.DurationMS.ToString(CultureInfo.InvariantCulture);
                        if (sensor.IsSquib())
                        {
                            value = sensor.SquibFireDurationMS.ToString(CultureInfo.InvariantCulture);
                        }
                        else if (sensor.IsDigitalOutput())
                        {
                            value = sensor.DigitalOutputDurationMS.ToString(CultureInfo.InvariantCulture);
                        }
                        break;
                    case ISO.TestObject.SensorSettings.Delay:
                        value = sensor.DelayMS.ToString(CultureInfo.InvariantCulture);
                        if (sensor.IsSquib())
                        {
                            value = sensor.SquibFireDelayMS.ToString(CultureInfo.InvariantCulture);
                        }
                        else if (sensor.IsDigitalOutput())
                        {
                            value = sensor.DigitalOutputDelayMS.ToString(CultureInfo.InvariantCulture);
                        }
                        break;
                    case ISO.TestObject.SensorSettings.LimitDuration:
                        value = sensor.LimitDuration.ToString(CultureInfo.InvariantCulture);
                        if (sensor.IsSquib())
                        {
                            value = sensor.LimitSquibFireDuration.ToString(CultureInfo.InvariantCulture);
                        }
                        else if (sensor.IsDigitalOutput())
                        {
                            value = sensor.DigitalOutputLimitDuration.ToString(CultureInfo.InvariantCulture);
                        }
                        break;
                    case ISO.TestObject.SensorSettings.OutputMode:
                        value = ((int)sensor.DigitalOutputMode).ToString(CultureInfo.InvariantCulture);
                        break;
                    case ISO.TestObject.SensorSettings.SQMode:
                        value = ((int)sensor.SquibFireMode).ToString(CultureInfo.InvariantCulture);
                        break;
                    case ISO.TestObject.SensorSettings.DIMode:
                        value = ((int)sensor.InputMode).ToString(CultureInfo.InvariantCulture);
                        break;
                    case ISO.TestObject.SensorSettings.DefaultValue:
                        value = sensor.ScaleMultiplier.DefaultValue.ToString(CultureInfo.InvariantCulture);
                        break;
                    case ISO.TestObject.SensorSettings.ActiveValue:
                        value = sensor.ScaleMultiplier.ActiveValue.ToString(CultureInfo.InvariantCulture);
                        break;
                    default:
                        continue; // If we don't know about a setting we shouldn't overwrite it with blank.
                }
                settings.Add(new ISO.TestObject.SensorSetting(field, value, channelName, sensor.SerialNumber));
            }

            foreach (var setting in settings)
            {
                GetISOTestObject().SetSensorSetting(channelName, sensor.SerialNumber, setting);
            }
        }

        public TestObject()
        {
            //PopulateTemplates();
            _isoTestObject = new ISO.TestObject();
            Template = new TestObjectTemplate();
            ParentObject = "";
            SysBuilt = false;
        }

        public DASHardware[] Hardware
        {
            get
            {
                var hardware = new List<DASHardware>(_hardware.Values.ToArray());
                hardware.Sort();
                return hardware.ToArray();
            }
        }

        public void Initialize(TestObject copy)
        {
            //PopulateTemplates();
            var db = ISO13499FileDb.IsoDb;
            _isoTestObject = new ISO.TestObject(copy.GetISOTestObject(), ref db);
            SerialNumber = copy.SerialNumber;
            if (null != copy.Template)
            {
                var tot = new TestObjectTemplate(copy.Template, ref db);
                SetTemplateDontResetISOObject(tot);
            }
            var copyISOTO = copy.GetISOTestObject();
            var ISOTO = GetISOTestObject();

            var hardware = new List<DASHardware>();
            foreach (var das in copy.Hardware)
            {
                hardware.Add(new DASHardware(das, null));
            }
            foreach (var h in hardware)
            {
                _hardware.Add(h.SerialNumber, h);
            }
            ParentObject = copy.ParentObject;
            SysBuilt = copy.SysBuilt;
            if (SysBuilt)
            {
                _isoTestObject.SerialNumberConverted = copy.SerialNumberConverted;
            }
        }
        public TestObject(TestObject copy)
        {
            Initialize(copy);
            DbTimeStamp = copy.DbTimeStamp;
        }
        private string _serialNumber = string.Empty;
        public string SerialNumber
        {
            get => _serialNumber;
            set
            {
                SetProperty(ref _serialNumber, value, Tags.SerialNumber.ToString());
                GetISOTestObject().SerialNumber = value;
            }
        }
        public string SerialNumberOrOriginalSerialNumber
        {
            get
            {
                if (GetISOTestObject().Embedded)
                {
                    return GetISOTestObject().OriginalSerialNumber;
                }
                return string.IsNullOrWhiteSpace(SerialNumberConverted) ? SerialNumber : SerialNumberConverted;
            }
        }
        private string _serialNumberConverted = string.Empty;
        public string SerialNumberConverted
        {
            get => _serialNumberConverted;
            set => SetProperty(ref _serialNumberConverted, value, Tags.SerialNumberConverted.ToString());
        }
        public string DisplaySerialNumber
        {
            get
            {
                if (string.IsNullOrWhiteSpace(SerialNumberConverted) && !SysBuilt)
                {
                    return SerialNumberOrOriginalSerialNumber;
                }
                return SerialNumberConverted;
            }
            set
            {
                //We assume that this is an Added Group being renamed
                SerialNumber = TestSetupName + "_" + value;
                SerialNumberConverted = value;
                GetISOTestObject().OriginalSerialNumber = SerialNumber;
                Template.OriginalTemplateName = SerialNumber + "_Template";
                GetISOTestObject().OriginalTemplate = Template.OriginalTemplateName;
            }
        }

        public string TestSetupName { get; set; } = string.Empty;

        private string _testObjectType = "?";

        public string TestObjectType
        {
            get => _testObjectType;
            set => SetProperty(ref _testObjectType, value, Tags.TestObjectType.ToString());
        }

        private string _parentObject = "";

        public string ParentObject
        {
            get => _parentObject;
            set
            {
                IsDirty = true;
                SetProperty(ref _parentObject, value, Tags.ParentObject.ToString());
                GetISOTestObject().ParentObject = value;
            }
        }
        private bool _sysBuilt;
        public bool SysBuilt
        {
            get => _sysBuilt;
            set => SetProperty(ref _sysBuilt, value, Tags.SysBuilt.ToString());
        }
        private Dictionary<string, DASHardware> _hardware = new Dictionary<string, DASHardware>();
        public bool ContainsHardware(DASHardware h)
        {
            return _hardware.ContainsKey(h.SerialNumber);
        }
        public void SetHardwareFromISO()
        {
            _hardware.Clear();
            var isoTO = GetISOTestObject();
            foreach (var hid in isoTO.HardwareIds)
            {
                var h = DASHardwareList.GetList().GetHardware(hid);
                if (null == h)
                {
                    continue;
                }
                //just making sure we have a copy and not the original hardware record.
                h = new DASHardware(h.GetHardware());
                h.SetTimeStampMemory(h.GetTimeStampMemory());
                if (!_hardware.ContainsKey(h.SerialNumber))
                {
                    _hardware[h.SerialNumber] = h;
                }
            }
        }

        /// <summary>
        /// this call is intended to be available to test template to update the hardware for the group in memory
        /// it is not intended to have that hardware stored in the db currently
        /// </summary>
        /// <param name="hardware"></param>
        public void SetHardware(DASHardware[] hardware)
        {
            _hardware.Clear();
            var hids = new List<string>();
            foreach (var h in hardware)
            {
                _hardware[h.SerialNumber] = h;
                if (!hids.Contains(h.SerialNumber))
                {
                    hids.Add(h.SerialNumber);
                }
            }
            GetISOTestObject().HardwareIds = hids.ToArray();
        }

        public void AddHardware(DASHardware hardware)
        {
            var stamp = hardware.GetTimeStampMemory();
            //just making sure we have a copy and not the original hardware record
            hardware = new DASHardware(hardware.GetHardware());
            hardware.SetTimeStampMemory(stamp);
            IsDirty = true;
            var toAdd = hardware;
            if (hardware.IsDummy())
            {
                var key = hardware.SerialNumber;
                if (_hardware.ContainsKey(key))
                {
                    var current = 1;
                    while (_hardware.ContainsKey(key))
                    {
                        current++;
                        key = string.Format("{0}({1:00})", hardware.SerialNumber, current);
                    }
                    toAdd = new DASHardware(hardware.GetHardware());
                    toAdd.SetTimeStampMemory(hardware.GetTimeStampMemory());
                    toAdd.SerialNumber = key;
                }
                else
                {
                    toAdd = new DASHardware(hardware.GetHardware());
                    toAdd.SetTimeStampMemory(hardware.GetTimeStampMemory());
                }
            }
            else
            {
                toAdd = new DASHardware(hardware.GetHardware());
                toAdd.SetTimeStampMemory(hardware.GetTimeStampMemory());
            }
            if (_hardware.ContainsKey(toAdd.SerialNumber))
            {
                return;
            }
            _hardware.Add(toAdd.SerialNumber, toAdd);
            //toAdd.PropertyChanged += addedHardware_PropertyChanged;
            OnPropertyChanged(Tags.Hardware.ToString());
            var hids = new List<string>();
            foreach (var h in Hardware)
            {
                hids.Add(h.GetHardware().GetId());
            }
            _isoTestObject.HardwareIds = hids.ToArray();
        }
        public ISO.TestObject GetISOTestObject()
        {
            return _isoTestObject;
        }

        private TestObjectTemplate _template = null;
        public TestObjectTemplate Template
        {
            get => _template;
            set
            {
                if (value == _template)
                {
                    return;
                }
                if (null == value)
                {
                    _template = value;
                    return;
                }
                if (GetISOTestObject().Template != value.TemplateName)
                {
                    var db = ISO13499FileDb.IsoDb;
                    GetISOTestObject().SetTemplate(value.TemplateName, ref db);
                }
                SetProperty(ref _template, value, Tags.Template.ToString());
                OnPropertyChanged(Tags.TemplateIndex.ToString());
                OnPropertyChanged(Tags.ChannelsDescription.ToString());
                OnPropertyChanged(Tags.LastModifiedText.ToString());
                OnPropertyChanged(Tags.TemplateDescription.ToString());
                OnPropertyChanged(Tags.TemplateImage.ToString());
                OnPropertyChanged(Tags.Zones.ToString());
                OnPropertyChanged(Tags.SelectedGlobalRangeCACOption.ToString());
                var zoneNames = new List<string>();
                foreach (var z in Template.TemplateZones)
                {
                    zoneNames.Add(z.Name);
                }
                ZoneNames = zoneNames.ToArray();
            }
        }
        public void SetTemplateDontResetISOObject(TestObjectTemplate value)
        {
            if (value == _template)
            {
                return;
            }
            if (null == value)
            {
                _template = value;
                return;
            }
            try
            {
                _isoTestObject?.SetTemplateOnly(value.TemplateName);
            }
            catch (Exception)
            {
            }

            var db = ISO13499FileDb.IsoDb;
            SetProperty(ref _template, new TestObjectTemplate(value, ref db), Tags.Template.ToString());
            OnPropertyChanged(Tags.TemplateIndex.ToString());
            OnPropertyChanged(Tags.ChannelsDescription.ToString());
            OnPropertyChanged(Tags.LastModifiedText.ToString());
            OnPropertyChanged(Tags.TemplateDescription.ToString());
            OnPropertyChanged(Tags.TemplateImage.ToString());
            OnPropertyChanged(Tags.Zones.ToString());
            OnPropertyChanged(Tags.SelectedGlobalRangeCACOption.ToString());
            var zoneNames = new List<string>();
            foreach (var z in value.TemplateZones)
            {
                zoneNames.Add(z.Name);
            }
            ZoneNames = zoneNames.ToArray();
        }
        public Dictionary<string, string> GetValues()
        {
            var elementNameValuePairs = new Dictionary<string, string>();
            var isoTestObject = GetISOTestObject();

            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.SerialNumber.ToString()] = SerialNumber;
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.LastModifiedBy.ToString()] = isoTestObject.LastModifiedBy;
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.LastModified.ToString()] = isoTestObject.LastModified.ToString(CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.Template.ToString()] = (null != Template) ? Template.TemplateName : "";
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.LocalOnly.ToString()] = isoTestObject.LocalOnly.ToString();
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.ParentObject.ToString()] = ParentObject ?? "";
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.SysBuilt.ToString()] = SysBuilt.ToString();
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.Embedded.ToString()] = isoTestObject.Embedded.ToString(CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.OriginalTemplate.ToString()] = isoTestObject.OriginalTemplate;
            elementNameValuePairs[DbOperations.TestSetups.TestObjectsFields.OriginalSerialNumber.ToString()] = isoTestObject.OriginalSerialNumber;

            return elementNameValuePairs;
        }
        private List<string> _zoneNames = new List<string>();
        public string[] ZoneNames
        {
            get => _zoneNames.ToArray();
            set => SetProperty(ref _zoneNames, new List<string>(value), Tags.ZoneNames.ToString());
        }
        public string TemplateType => null == Template ? "" : Template.TestObjectType;

        public bool LocalOnly { get; } = false;

        private ISO.TestObject _isoTestObject = null;
        public TestObject(ISO.TestObject to, bool sysBuilt)
        {
            //PopulateTemplates();
            _isoTestObject = to;
            SerialNumber = to.SerialNumber;
            if (sysBuilt)
            {
                SerialNumberConverted = to.SerialNumber.Remove(0, SerialNumber.LastIndexOf('_') + 1);
                if (to.Template == "SysBuilt_(no channels)") // add to string resources            this whole thing not needed anymore?
                {
                    Template = TestObjectTemplateCollection.TemplateCollection.SysBuiltTestObjectTemplate;
                }
                else
                {
                    Template = TestObjectTemplateCollection.TemplateCollection.GetTemplate(to.Template);
                }
                TestObjectType = to.TestObjectType;
                SysBuilt = true;
            }
            else
            {
                Template = TestObjectTemplateCollection.TemplateCollection.GetTemplate(to.Template);
            }
            LocalOnly = to.LocalOnly;
            foreach (var id in to.HardwareIds)
            {
                DASHardware da = null;
                try
                {
                    da = DASHardwareList.GetList().GetHardware(id);
                }
                catch (Exception)
                {
                    //DTS.Utilities.Logging.APILogger.Log(ex);
                }
                if (null != da && !ContainsHardware(da))
                {
                    AddHardware(da);
                }
            }
        }
    }
}