using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;

namespace DatabaseExport.ISO
{
    public class TestObject
    {
        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()
        {
            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 = ISO.TestObjectTemplate.GetTemplate(ref db, Template);
            SetTemplate(template);
        }
        public void SetTemplate(ISO.TestObjectTemplate template)
        {
            _allChannels.Clear();
            if (null == template) return;
            Template = template.TemplateName;
            AllChannels = template.Channels.Select(c => new TestObjectChannel(c, this, template)).ToArray();
        }
        private bool _localOnly;
        public bool LocalOnly
        {
            get => _localOnly;
            set => _localOnly = value;
        }
        private string _lastModifiedBy;
        public string LastModifiedBy
        {
            get => _lastModifiedBy;
            set => _lastModifiedBy = value;
        }
        private DateTime _lastModified;
        public DateTime LastModified
        {
            get => _lastModified;
            set => _lastModified = value;
        }
        private TestObject(DataRow dr, ref ISO13499FileDb db)
        {
            OriginalTemplate = "";
            OriginalSerialNumber = "";
            SerialNumberConverted = string.Empty;
            TestObjectGuts(dr, ref db);
        }

        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; }

        private void TestObjectGuts(DataRow dr, ref ISO13499FileDb db)
        {
            SerialNumber = (string)dr["SerialNumber"];
            LocalOnly = Convert.ToBoolean(dr["LocalOnly"]);
            SetTemplate((string)dr["Template"], ref db);
            LastModifiedBy = (string)dr["LastModifiedBy"];
            LastModified = Convert.ToDateTime(dr["LastModified"]);
            SysBuilt = Convert.ToBoolean(dr["SysBuilt"]);
            var o = dr["Embedded"];
            if (!DBNull.Value.Equals(o))
            {
                Embedded = Convert.ToBoolean(o);
            }
            o = dr["OrigSerialNumber"];
            if (!DBNull.Value.Equals(o))
            {
                OriginalSerialNumber = Convert.ToString(o);
            }
            o = dr["OrigTEmplate"];
            if (!DBNull.Value.Equals(o))
            {
                OriginalTemplate = Convert.ToString(o);
            }
            try
            {
                if (!DBNull.Value.Equals(dr["ParentObject"]))
                {
                    ParentObject = (string)dr["ParentObject"];
                }
            }
            catch (Exception) { /*APILogger.Log(ex);*/ }
            try
            {
                using (var sql = DbOperations.GetCommand())
                {
                    DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestObjectChannelSettings.Fields.TestObjectSerial),
                        SqlDbType.NVarChar, SerialNumber);
                    sql.CommandText = string.Format("SELECT * from [{0}] where [{1}]=@{1}", DbOperations.TestObjectChannelSettings.TableName,
                        DbOperations.TestObjectChannelSettings.Fields.TestObjectSerial);

                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        if (ds.Tables[0].Rows.Count <= 0) return;
                        foreach (DataRow row in ds.Tables[0].Rows)
                        {
                            try
                            {
                                var channelId = (string)row[DbOperations.TestObjectChannelSettings.Fields.ChannelId.ToString()];
                                var sensor = (string)row[DbOperations.TestObjectChannelSettings.Fields.SensorSerial.ToString()];
                                var settings = (string)row[DbOperations.TestObjectChannelSettings.Fields.Setting.ToString()];
                                if (string.IsNullOrEmpty(channelId) || string.IsNullOrEmpty(sensor) ||
                                    string.IsNullOrEmpty(settings)) continue;
                                var sensorsettings = GetSettingsFromString(settings, sensor, channelId);
                                foreach (var setting in sensorsettings)
                                {
                                    SetSensorSetting(channelId, sensor, setting);
                                }
                            }
                            catch (Exception) {/* APILogger.Log(ex);*/ }
                        }
                    }
                }
            }
            catch (Exception) { /*APILogger.Log(ex); */}
        }
        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 = (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 enum SensorSettings
        {
            Range,
            CFC,
            Polarity,
            Position,
            LimitDuration,
            Duration,
            Delay,
            OutputMode,
            SQMode,
            DIMode,
            DefaultValue,
            ActiveValue
        }
        public class SensorSetting
        {
            public string ChannelId { get; set; }
            public string SerialNumber { get; set; }
            public SensorSettings Setting { get; set; }
            public string Value { get; set; }
            public SensorSetting(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 Dictionary<string, Dictionary<string, Dictionary<SensorSettings, SensorSetting>>> _sensorSettings = new Dictionary<string, Dictionary<string, Dictionary<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<SensorSettings, SensorSetting>>(); }
            if (!_sensorSettings[channelId].ContainsKey(serialNumber)) { _sensorSettings[channelId][serialNumber] = new Dictionary<SensorSettings, SensorSetting>(); }
            _sensorSettings[channelId][serialNumber][setting.Setting] = setting;
        }
        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;
            var e = copy._sensorSettings.GetEnumerator();
            _sensorSettings = new Dictionary<string, Dictionary<string, Dictionary<SensorSettings, SensorSetting>>>();
            while (e.MoveNext())
            {
                if (!_sensorSettings.ContainsKey(e.Current.Key))
                {
                    _sensorSettings[e.Current.Key] = new Dictionary<string, Dictionary<SensorSettings, SensorSetting>>();
                }
                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<SensorSettings, SensorSetting>();
                    }
                    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);
                    }
                }
            }
        }
        private const char CHANNEL_SEPARATOR = 'x';
        private void GetHardwareAndSensors()
        {
            using (var sql = DbOperations.GetCommand())
            {
                DbOperations.CreateParam(sql, "@TestObject", SqlDbType.NVarChar, SerialNumber);

                sql.CommandText = "SELECT [HardwareId] from [tblTestObjectHardware] WHERE [TestObject]=@TestObject";

                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    if (null != ds && ds.Tables.Count > 0)
                    {
                        var ids = new List<string>();
                        for (var i = 0; i < ds.Tables[0].Rows.Count; i++)
                        {
                            var id = (string)ds.Tables[0].Rows[i]["HardwareId"];
                            var tokens = id.Split('_');
                            if (tokens.Length == 3)
                            {
                                var sb = new StringBuilder();
                                sb.AppendFormat("{0}_{1}", tokens[0], tokens[1]);
                                var index = tokens[2].IndexOf(CHANNEL_SEPARATOR);
                                if (index >= 0) { sb.Append(tokens[2].Substring(index)); }
                                id = sb.ToString();
                            }
                            if (!ids.Contains(id)) { ids.Add(id); }
                        }
                        _hardwareIds = ids;
                    }
                }
            }
            var channelLookup = AllChannels.ToDictionary(ch => ch.GetID());
            using (var sql = DbOperations.GetCommand())
            {
                DbOperations.CreateParam(sql, "@TestObjectId", SqlDbType.NVarChar, SerialNumber);

                sql.CommandText = "SELECT [UIChannelID],[SensorId],[ZoneId],[HardwareId],[ChannelIdx] FROM [tblTestObjectSensors] WHERE [TestObjectId]=@TestObjectId";

                using (var ds = DbOperations.Connection.QueryDataSet(sql))
                {
                    if (null != ds && ds.Tables.Count > 0)
                    {
                        foreach (DataRow dr in ds.Tables[0].Rows)
                        {
                            var id = Convert.ToString(dr[0]);
                            var sensorId = "";
                            var hardwareId = "";
                            var channelIdx = -1;
                            if (!DBNull.Value.Equals(dr["ChannelIdx"])) { channelIdx = Convert.ToInt32(dr["ChannelIdx"]); }
                            if (!DBNull.Value.Equals(dr[1])) { sensorId = Convert.ToString(dr[1]); }
                            if (!DBNull.Value.Equals(dr[3]))
                            {
                                hardwareId = Convert.ToString(dr[3]);
                                var tokens = hardwareId.Split('_');
                                if (3 == tokens.Length)
                                {
                                    var sb = new StringBuilder();
                                    sb.AppendFormat("{0}_{1}", tokens[0], tokens[1]);
                                    var index = tokens[2].IndexOf('x');
                                    if (index >= 0) { sb.Append(tokens[2].Substring(index)); }
                                    hardwareId = sb.ToString();
                                }
                            }
                            if (!channelLookup.ContainsKey(id)) continue;
                            channelLookup[id].SensorSerialNumber = sensorId;
                            channelLookup[id].HardwareId = hardwareId;
                            channelLookup[id].ChannelIDX = channelIdx;
                        }
                    }
                }
            }
            SortChannels();
        }
        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();
        }
        public static TestObject GetTestObject(string serialNumber, ref ISO13499FileDb db)
        {
            try
            {
                TestObject testObject = null;
                using (var sql = DbOperations.GetCommand())
                {
                    DbOperations.CreateParam(sql, "@1", SqlDbType.NVarChar, serialNumber);
                    sql.CommandText = "Select * FROM [tblTestObjects] WHERE [SerialNumber] = @1";
                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        if (null != ds && ds.Tables[0].Rows.Count > 0)
                        {
                            //var testObject =  new TestObject(ds.Tables[0].Rows[0], ref db);
                            testObject = new TestObject(ds.Tables[0].Rows[0], ref db);
                            testObject.GetHardwareAndSensors();
                            //return testObject;
                        }
                    }
                }
                return testObject;
            }
            catch (Exception) { /*APILogger.Log("failed to retrieve test objects", ex);*/ }
            return null;
        }
    }
}