using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using DTS.Common.Interface.Groups;
using DTS.Common.Storage;
using DTS.Common.Utilities.Logging;
using DTS.Common.Enums.Sensors;
using DTS.Common.Interface.GroupTemplate;

// ReSharper disable once CheckNamespace
namespace DTS.Common.ISO
{
    public class TestObject : IComparable, ITestObject
    {
        private List<TestObjectChannel> _allChannels = new List<TestObjectChannel>();
        public TestObjectChannel[] AllChannels
        {
            get => _allChannels.ToArray();
            set
            {
                _allChannels = new List<TestObjectChannel>(value);
                SortChannels();
            }
        }

        public void SortChannels()
        {
            _allChannels.Sort();
        }

        public TestObjectChannel GetChannel(string channelid)
        {
            return Array.Find(AllChannels, ch => ch.GetId() == channelid || ch.Name == channelid);
        }

        public override string ToString()
        {
            if (Embedded)
            {
                if (string.IsNullOrWhiteSpace(DisplaySerialNumber))
                {
                    var index = SerialNumber.LastIndexOf('_');
                    var displaySerialNumber = SerialNumber;
                    if (index >= 0)
                    {
                        displaySerialNumber = SerialNumber.Substring(index + 1);
                    }
                    return displaySerialNumber;
                }
                return DisplaySerialNumber;
            }
            return SerialNumber;
            //return Embedded ? 
            //    DisplaySerialNumber : SerialNumber;
        }

        public string DisplaySerialNumber => SysBuilt ? SerialNumberConverted : OriginalSerialNumber;

        public string SerialNumberConverted { get; set; }

        public string SerialNumber { get; set; }

        public string SerialNumberOrOriginalSerialNumber => Embedded ? OriginalSerialNumber : SerialNumber;

        public string TestObjectType { get; set; }

        public string ParentObject { get; set; }

        public bool SysBuilt { get; set; }

        public string TextL1 { get; set; }

        private List<string> _hardwareIds = new List<string>();
        public string[] HardwareIds
        {
            get => _hardwareIds.ToArray();
            set { _hardwareIds.Clear(); _hardwareIds.AddRange(value); }
        }

        public string Template { get; set; }

        public void SetTemplateOnly(string value) { Template = value; }
        public void SetTemplate(string value, ref ISO13499FileDb db)
        {
            Template = value;
            var template = TestObjectTemplate.GetTemplate(ref db, Template);
            SetTemplate(template);
        }
        public void SetTemplate(TestObjectTemplate template)
        {
            _allChannels.Clear();
            if (null == template) return;
            Template = template.TemplateName;
            AllChannels = template.Channels.Select(c => new TestObjectChannel(c, this, template)).ToArray();
        }

        public bool LocalOnly { get; set; }

        public string LastModifiedBy { get; set; }

        public DateTime LastModified { get; set; }

        public TestObject(TestObject copy, TestObjectTemplate template, ISO13499FileDb db)
        {
            SerialNumberConverted = string.Empty;
            _allChannels = new List<TestObjectChannel>();
            foreach (var ch in copy.AllChannels) { _allChannels.Add(new TestObjectChannel(ch, this, template)); }
            Embedded = copy.Embedded;
            _hardwareIds = new List<string>();
            _hardwareIds.AddRange(copy.HardwareIds.ToArray());
            LastModified = copy.LastModified;
            LastModifiedBy = copy.LastModifiedBy;
            LocalOnly = copy.LocalOnly;
            OriginalSerialNumber = copy.OriginalSerialNumber;
            OriginalTemplate = copy.OriginalTemplate;
            ParentObject = copy.ParentObject;
            _sensorSettings = new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>>();
            using (var e1 = copy._sensorSettings.GetEnumerator())
            {
                while (e1.MoveNext())
                {
                    using (var e2 = e1.Current.Value.GetEnumerator())
                    {
                        while (e2.MoveNext())
                        {
                            using (var e3 = e2.Current.Value.GetEnumerator())
                            {
                                while (e3.MoveNext())
                                {
                                    if (!_sensorSettings.ContainsKey(e1.Current.Key))
                                    {
                                        _sensorSettings.Add(e1.Current.Key,
                                            new Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>());
                                    }
                                    if (!_sensorSettings[e1.Current.Key].ContainsKey(e2.Current.Key))
                                    {
                                        _sensorSettings[e1.Current.Key].Add(e2.Current.Key,
                                            new Dictionary<SensorConstants.SensorSettings, SensorSetting>());
                                    }
                                    if (!_sensorSettings[e1.Current.Key][e2.Current.Key].ContainsKey(e3.Current.Key))
                                    {
                                        _sensorSettings[e1.Current.Key][e2.Current.Key].Add(e3.Current.Key,
                                            new SensorSetting(e3.Current.Value));
                                    }
                                }
                            }
                        }
                    }
                }
            }
            SerialNumber = copy.SerialNumber;
            SysBuilt = copy.SysBuilt;
            Template = copy.Template;
            TestObjectType = copy.TestObjectType;
            TextL1 = copy.TextL1;
        }

        public bool Embedded { get; set; }

        /// <summary>
        /// original serial number of this group (the serial number will be changed once it's embedded in a test setup)
        /// </summary>
        public string OriginalSerialNumber { get; set; }

        /// <summary>
        /// the original template for this group (the template is also changed once it's embedded in a test setup)
        /// </summary>        
        public string OriginalTemplate { get; set; }


        public static SensorSetting[] GetSettingsFromString(string s, string sensor, string channelid)
        {
            var tokens = s.Split(',');

            return (from token in tokens select token.Split('=') into subtokens let setting = (SensorConstants.SensorSettings)Convert.ToInt32(subtokens[0]) select new SensorSetting(setting, subtokens[1], channelid, sensor)).ToArray();
        }
        public TestObject()
        {
            OriginalTemplate = "";
            OriginalSerialNumber = "";
            SerialNumberConverted = string.Empty;
            _allChannels = new List<TestObjectChannel>();
            _hardwareIds = new List<string>();
            LastModified = DateTime.MinValue;
            LastModifiedBy = "N/A";
            LocalOnly = false;
            SerialNumber = "";
            Template = "";
            ParentObject = "";
        }
        public class SensorSetting
        {
            public string ChannelId { get; set; }
            public string SerialNumber { get; set; }
            public SensorConstants.SensorSettings Setting { get; set; }
            public string Value { get; set; }
            public SensorSetting(SensorConstants.SensorSettings setting, string value, string channelId, string serialNumber)
            {
                ChannelId = channelId;
                Value = value;
                Setting = setting;
                SerialNumber = serialNumber;
            }
            public SensorSetting(SensorSetting copy)
            {
                ChannelId = copy.ChannelId;
                Value = copy.Value;
                Setting = copy.Setting;
                SerialNumber = copy.SerialNumber;
            }
        }
        private readonly Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>> _sensorSettings =
            new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>>();

        public SensorSetting[] GetSensorSettings(string channelId, string serialNumber)
        {
            if (!_sensorSettings.ContainsKey(channelId)) return new SensorSetting[0];
            return _sensorSettings[channelId].ContainsKey(serialNumber) ? _sensorSettings[channelId][serialNumber].Values.ToArray() : new SensorSetting[0];
        }
        public void SetSensorSetting(string channelId, string serialNumber, SensorSetting setting)
        {
            if (!_sensorSettings.ContainsKey(channelId)) { _sensorSettings[channelId] = new Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>(); }
            if (!_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId][serialNumber] = new Dictionary<SensorConstants.SensorSettings, SensorSetting>(); }
            _sensorSettings[channelId][serialNumber][setting.Setting] = setting;
        }
        private void RemoveSensorSetting(string channelId, string serialNumber)
        {
            if (!_sensorSettings.ContainsKey(channelId)) return;
            if (_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId].Remove(serialNumber); }
        }

        public TestObject(TestObject copy, ref ISO13499FileDb db)
        {
            SerialNumberConverted = string.Empty;
            OriginalSerialNumber = copy.OriginalSerialNumber;
            OriginalTemplate = copy.OriginalTemplate;
            Embedded = copy.Embedded;

            _allChannels = new List<TestObjectChannel>();

            var t = TestObjectTemplate.GetTemplate(ref db, Template);

            copy.SortChannels();
            foreach (var c in copy.AllChannels) { _allChannels.Add(new TestObjectChannel(c, this, t)); }

            for (var i = 0; i < copy.AllChannels.Length && i < _allChannels.Count; i++)
            {
                _allChannels[i].ChannelIdx = i;
            }

            _hardwareIds = new List<string>(copy.HardwareIds);
            LastModified = copy.LastModified;
            LastModifiedBy = copy.LastModifiedBy;
            LocalOnly = copy.LocalOnly;
            SerialNumber = copy.SerialNumber;
            Template = copy.Template;
            ParentObject = copy.ParentObject;
            SysBuilt = copy.SysBuilt;
            using (var e = copy._sensorSettings.GetEnumerator())
            {
                _sensorSettings =
                    new Dictionary<string, Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>>();
                while (e.MoveNext())
                {
                    if (!_sensorSettings.ContainsKey(e.Current.Key))
                    {
                        _sensorSettings[e.Current.Key] =
                            new Dictionary<string, Dictionary<SensorConstants.SensorSettings, SensorSetting>>();
                    }
                    using (var e2 = copy._sensorSettings[e.Current.Key].GetEnumerator())
                    {
                        while (e2.MoveNext())
                        {
                            if (!_sensorSettings[e.Current.Key].ContainsKey(e2.Current.Key))
                            {
                                _sensorSettings[e.Current.Key][e2.Current.Key] =
                                    new Dictionary<SensorConstants.SensorSettings, SensorSetting>();
                            }
                            using (var e3 = copy._sensorSettings[e.Current.Key][e2.Current.Key].GetEnumerator())
                            {
                                while (e3.MoveNext())
                                {
                                    _sensorSettings[e.Current.Key][e2.Current.Key][e3.Current.Key] =
                                        new SensorSetting(e3.Current.Value);
                                }
                            }
                        }
                    }
                }
            }

        }

        public string GetSerializedSetting(SensorSetting[] settings)
        {
            var sb = new StringBuilder();
            var bNeedComma = false;
            foreach (var setting in settings)
            {
                if (bNeedComma) { sb.Append(","); }
                bNeedComma = true;

                sb.AppendFormat("{0}={1}", (int)setting.Setting, setting.Value);
            }
            return sb.ToString();
        }

        private static int CompareTestObject(TestObject left, TestObject right)
        {
            if (left == right) { return 0; }
            if (null == left) { return -1; }
            return null == right ? 1 : string.Compare(left.SerialNumber, right.SerialNumber, StringComparison.Ordinal);
        }

        public int CompareTo(object o)
        {
            if (o is TestObject testObject)
            {
                return CompareTestObject(this, testObject);
            }
            throw new ArgumentException($"object {o} is not the same type as this instance (TestObject)");
        }
    }
}