using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using DTS.Common.Base;
using DTS.Common.DataModel;
using DTS.Common.ISO;

namespace DataPROWin7.DataModel
{
    public class TestObjectTemplate : BasePropertyChanged, IComparable<TestObjectTemplate>
    {
        #region enums and constants
        public enum Tags
        {
            ChannelCountText,
            PossibleChannelCountText,
            TemplateName,
            TemplateDescription,
            TestObject,
            TestObjectType,
            TemplateAllUIChannels,
            TemplateZones,
            AvailableTestObjectTypes,
            TestObjectIndex,
            TestObjectTypeIndex,
            CurrentZone,
            CurrentZoneIndex,
            AreZoneControlsEnabled,
            TemplateAllChannels,
            RequiredChannels
        }
        private enum GroupTemplateChannelFields
        {
            TestObjectNumber,
            NameOfTheChannel,
            LaboratoryChannelCode,
            CustomerChannelCode,
            Comments1,
            Location,
            Dimension,
            Direction,
            ChannelFrequencyClass,
            Unit,
            ReferenceSystem,
            TransducerType,
            TransducerId,
            PreFilterType,
            CutOffFrequency,
            ChannelAmplitudeClass,
            ReferenceChannel,
            ReferenceChannelName,
            DataSource,
            DataStatus,
            SamplingInterval,
            BitResolution,
            TimeOfFirstSample,
            NumberOfSamples,
            OffsetPostTest,
            TransducerNaturalFrequency,
            TransducerDampingRatio,
            Comments,
            FirstGlobalMaximumValue,
            TimeOfMaximumValue,
            FirstGlobalMinimumValue,
            TimeOfMinimumValue,
            StartOffsetInterval,
            EndOffsetInterval,
            MMEChannelId,
            MMEChannelType,
            Required,
            DisplayOrder,
            LocalOnly
        }
        private enum GroupTemplateFields
        {
            TemplateName,
            Icon,
            Description,
            LocalOnly,
            Version,
            LastModifiedBy,
            LastModified,
            CRC32,
            TestObjectType,
            TestObject,
            ParentTemplate,
            SysBuilt,
            OriginalTemplateName,
            Embedded
        };

        #endregion

        #region properties

        private string _lastModifiedBy = "N/A";
        public string LastModifiedBy
        {
            get => _lastModifiedBy;
            set => SetProperty(ref _lastModifiedBy, value, "LastModifiedBy");
        }

        private DateTime _lastModified = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
        public DateTime LastModified
        {
            get => _lastModified;
            set => SetProperty(ref _lastModified, value, "LastModified");
        }

        private DTS.Common.ISO.TestObjectTemplate _template;

        private List<TestObjectTemplateChannel> _requiredChannels = new List<TestObjectTemplateChannel>();
        public List<TestObjectTemplateChannel> RequiredChannels
        {
            get => _requiredChannels;
            set { _requiredChannels = value; OnPropertyChanged("RequiredChannels"); }
        }

        private string _templateParent = "";
        public string TemplateParent
        {
            get => _templateParent;
            set => SetProperty(ref _templateParent, value, "TemplateParent");
        }

        private bool _sysBuilt;
        public bool SysBuilt
        {
            get => _sysBuilt;
            set => SetProperty(ref _sysBuilt, value, "SysBuilt");
        }

        private bool _embedded;
        public bool Embedded
        {
            get => _embedded;
            set
            {
                _embedded = value;
                if (null != _template) { _template.Embedded = value; }
            }
        }

        private string _originalTemplateName = "";
        public string OriginalTemplateName
        {
            get => _originalTemplateName;
            set
            {
                _originalTemplateName = value;
                if (null != _template) { _template.OriginalTemplateName = value; }
            }
        }

        private string _name;
        public string TemplateName
        {
            get => _name;
            set => SetProperty(ref _name, value, Tags.TemplateName.ToString());
        }

        private string _desc;
        public string TemplateDescription
        {
            get => _desc;
            set => SetProperty(ref _desc, value, Tags.TemplateDescription.ToString());
        }

        private bool _bLocalOnly;

        public bool IsLocalOnly
        {
            get => _bLocalOnly;
            set => SetProperty(ref _bLocalOnly, value, "IsLocalOnly");
        }

        private MMETestObjects _testObject;
        public MMETestObjects TestObject
        {
            get => _testObject;
            set
            {
                SetProperty(ref _testObject, value, Tags.TestObject.ToString());
                if (null == _testObject) return;
                AvailableTestObjectTypes = ApplicationProperties.IsoDb.GetUniquePossibleChannelTypes(TestObjectTemplateChannel.NONISOCHANNELTYPE);
                if (AvailableTestObjectTypes.Length > 0) { TestObjectTypeIndex = 0; }
                else { TestObjectTypeIndex = -1; }
            }
        }

        private string _testObjectType;
        public string TestObjectType
        {
            get => _testObjectType;
            set
            {
                SetProperty(ref _testObjectType, value, Tags.TestObjectType.ToString());
                _channels = new List<MMEPossibleChannels>(ApplicationProperties.IsoDb.GetPossibleChannelsForType(_testObjectType));
                TemplateAllChannels = _channels.Select(pc => new TestObjectTemplateChannel(new TestObjectTemplateChannel(pc), /*ref db,*/ _template)).ToArray();
                AssignOrders();
                OnPropertyChanged(Tags.PossibleChannelCountText.ToString());
                OnPropertyChanged(Tags.ChannelCountText.ToString());
                OnPropertyChanged(Tags.TestObjectTypeIndex.ToString());
            }
        }

        public void AssignOrders()
        {
            var allChannels = TemplateAllChannels.ToList();
            if (!allChannels.Any()) { return; }
            allChannels.Sort();
            var maxDisplayOrder = (from ch in allChannels select ch.DisplayOrder).Max();
            foreach (var ch in allChannels)
            {
                if (-1 == ch.DisplayOrder)
                {
                    ch.DisplayOrder = ++maxDisplayOrder;
                }
            }
        }
        private List<MMEPossibleChannels> _channels = new List<MMEPossibleChannels>();

        //11287 Out of memory exception when importing large CSV Test Setup files
        //reduced one collection of channels to refer to channel super class members
        public TestObjectTemplateChannel[] TemplateAllChannels
        {
            get
            {
                var channels = (from ch in _allUIChannels select ch.Channel).ToArray();
                return channels;
            }
            set
            {
                TemplateAllUIChannels = value.Select(c => new TemplateChannelUI(c)).ToArray();
            }
        }
        private List<TemplateChannelUI> _allUIChannels = new List<TemplateChannelUI>();
        public TemplateChannelUI[] TemplateAllUIChannels
        {
            get => _allUIChannels.ToArray();
            set => SetProperty(ref _allUIChannels, new List<TemplateChannelUI>(value), Tags.TemplateAllUIChannels.ToString());
        }


        private List<MMETestObjects> _testObjects = new List<MMETestObjects>();

        private List<string> _availableTestObjectTypes = null;
        public string[] AvailableTestObjectTypes
        {
            get
            {
                if (null != _availableTestObjectTypes) return _availableTestObjectTypes.ToArray();
                if (null == TestObject) { return new string[0]; }
                _availableTestObjectTypes = new List<string>(ApplicationProperties.IsoDb.GetTestObjectTypeForTestObject(TestObject.Test_Object));
                return _availableTestObjectTypes.ToArray();
            }
            set => SetProperty(ref _availableTestObjectTypes, new List<string>(value), Tags.AvailableTestObjectTypes.ToString());
        }

        private int _testObjectTypeIndex = -1;
        public int TestObjectTypeIndex
        {
            get
            {
                if (string.IsNullOrEmpty(TestObjectType)) { return -1; }
                return _availableTestObjectTypes.IndexOf(TestObjectType);
            }
            set
            {
                TestObjectType = value >= 0 ? _availableTestObjectTypes[value] : null;
                SetProperty(ref _testObjectTypeIndex, value, Tags.TestObjectTypeIndex.ToString());

                TemplateAllChannels = _channels.Select(pc => new TestObjectTemplateChannel(new TestObjectTemplateChannel(pc), /*ref db,*/ _template)).ToArray();
                AssignOrders();
            }
        }
        #endregion

        #region methods
        public void MarkChanged(string tag)
        {
            OnPropertyChanged(tag);
        }

        public int CompareTo(TestObjectTemplate rhs)
        {
            if (null == rhs) { return 1; }
            return this == rhs ? 0 : string.Compare(TemplateName, rhs.TemplateName, StringComparison.Ordinal);
        }
        public override string ToString()
        {
            return Embedded ? OriginalTemplateName : TemplateName;
        }

        public DTS.Common.ISO.TestObjectTemplate ToISOTestObjectTemplate()
        {
            var template = new DTS.Common.ISO.TestObjectTemplate(TemplateName, IsLocalOnly)
            {
                Description = TemplateDescription,
                OriginalTemplateName = OriginalTemplateName,
                Embedded = Embedded,
                Icon = "",
                LocalOnly = IsLocalOnly,
                TestObject = TestObject.Test_Object,
                TestObjectType = TestObjectType
            };

            template.TemplateParent = TemplateParent;
            template.Channels = TemplateAllChannels;
            template.SysBuilt = SysBuilt;
            return template;
        }

        #endregion

        #region constructors and initialization
        public TestObjectTemplate(TestObjectTemplate copy, ref ISO13499FileDb db)
        {
            if (null != copy._template) { _template = new DTS.Common.ISO.TestObjectTemplate(copy._template, ref db); }
            TemplateDescription = copy.TemplateDescription;
            TemplateParent = copy.TemplateParent;
            TemplateName = copy.TemplateName;
            LastModified = copy.LastModified;
            LastModifiedBy = copy.LastModifiedBy;
            TestObject = copy.TestObject;
            TestObjectType = copy.TestObjectType;
            foreach (var c in copy.RequiredChannels)
            {
                RequiredChannels.Add(new TestObjectTemplateChannel(c, /*ref db,*/ _template));
            }
            TemplateAllChannels = copy.TemplateAllChannels.Select(c => new TestObjectTemplateChannel(c, /*ref db,*/ _template)).ToArray();

            SysBuilt = copy.SysBuilt;
            Embedded = copy.Embedded;
            OriginalTemplateName = copy.OriginalTemplateName;
        }
        public TestObjectTemplate(DTS.Common.ISO.TestObjectTemplate template, ref ISO13499FileDb db)
        {
            Initialize(template, ref db, null);
        }
        public TestObjectTemplate(DTS.Common.ISO.TestObjectTemplate template, ref ISO13499FileDb db, List<MMETestObjects> testObjects)
        {
            Initialize(template, ref db, testObjects);
        }
        private void Initialize(DTS.Common.ISO.TestObjectTemplate template, ref ISO13499FileDb db, List<MMETestObjects> testObjects)
        {
            _template = template;
            TemplateDescription = template.Description;
            TemplateName = template.TemplateName;
            LastModified = template.LastModified;
            LastModifiedBy = template.LastModifiedBy;

            //if a list of test objects is provided, check if the test object we wish is in the list, if so use it
            var bFoundTestObject = false;
            if (null != testObjects)
            {
                var matches = from to in testObjects where to.Test_Object == template.TestObject select to;
                var mmeTestObjectses = matches as MMETestObjects[] ?? matches.ToArray();
                if (mmeTestObjectses.Any())
                {
                    TestObject = mmeTestObjectses[0];
                    bFoundTestObject = true;
                }
            }
            if (!bFoundTestObject)
            {
                TestObject = ApplicationProperties.IsoDb.GetTestObjectByIso(template.TestObject);
            }
            TestObjectType = template.TestObjectType;
            OriginalTemplateName = template.OriginalTemplateName;
            Embedded = template.Embedded;

            TemplateAllChannels = template.Channels.Select(c => new TestObjectTemplateChannel(c, /*ref db,*/ _template)).ToArray();
            TemplateParent = template.TemplateParent;
            SysBuilt = template.SysBuilt;
        }
        public TestObjectTemplate()
        {
            TemplateName = string.Empty;
            TemplateDescription = string.Empty;
            TemplateParent = string.Empty;
            TestObject = ApplicationProperties.IsoDb.GetTestObjects(false).FirstOrDefault();
        }

        #endregion

        #region XML Serialization
        public static DTS.Common.ISO.TestObjectTemplate ReadXML(System.Xml.XmlElement root, Dictionary<long, MMEPossibleChannels> importChannels)
        {
            var template = new DTS.Common.ISO.TestObjectTemplate("", false);
            foreach (var node in root.ChildNodes)
            {
                if (node is System.Xml.XmlElement) { ProcessXMLElement(node as System.Xml.XmlElement, ref template, importChannels); }
            }
            return template;
        }
        private static void ProcessXMLElement(System.Xml.XmlElement node, ref DTS.Common.ISO.TestObjectTemplate template, Dictionary<long, MMEPossibleChannels> importChannels)
        {
            if (Enum.TryParse(node.Name, out GroupTemplateFields field))
            {
                switch (field)
                {
                    case GroupTemplateFields.CRC32: template.CRC32 = Convert.ToInt32(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                    case GroupTemplateFields.Description: template.Description = node.InnerText; break;
                    case GroupTemplateFields.Icon: template.Icon = node.InnerText; break;
                    case GroupTemplateFields.LastModified: template.LastModified = DateTime.Parse(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                    case GroupTemplateFields.LastModifiedBy: template.LastModifiedBy = node.InnerText; break;
                    case GroupTemplateFields.LocalOnly: template.LocalOnly = Convert.ToBoolean(node.InnerText); break;
                    case GroupTemplateFields.ParentTemplate: template.TemplateParent = node.InnerText; break;
                    case GroupTemplateFields.SysBuilt: template.SysBuilt = Convert.ToBoolean(node.InnerText); break;
                    case GroupTemplateFields.TemplateName: template.TemplateName = node.InnerText.Trim(); break;
                    case GroupTemplateFields.TestObject: template.TestObject = node.InnerText; break;
                    case GroupTemplateFields.TestObjectType: template.TestObjectType = node.InnerText; break;
                    case GroupTemplateFields.Version: template.Version = Convert.ToInt32(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                    case GroupTemplateFields.OriginalTemplateName: template.OriginalTemplateName = node.InnerText; break;
                    case GroupTemplateFields.Embedded: template.Embedded = Convert.ToBoolean(node.InnerText); break;
                    default: throw new NotSupportedException("TestObjectTemplate::ProcessXMLElement unknown field: " + field.ToString());
                }
            }
            else if (node.Name == "TemplateChannels")
            {
                foreach (var child in node.ChildNodes)
                {
                    ProcessChannelXMLNode(child as System.Xml.XmlElement, ref template, importChannels);
                }
                var channels = new List<TestObjectTemplateChannel>(template.Channels);
                channels.Sort();
                template.Channels = channels.ToArray();
            }
        }
        private static void ProcessChannelXMLNode(System.Xml.XmlElement root, ref DTS.Common.ISO.TestObjectTemplate template, Dictionary<long, MMEPossibleChannels> importChannels)
        {
            var existingChannels = new List<TestObjectTemplateChannel>(template.Channels);

            var values = new Dictionary<GroupTemplateChannelFields, string>();
            foreach (var child in root.ChildNodes)
            {
                var node = child as System.Xml.XmlElement;
                if (null == node) { continue; }

                if (Enum.TryParse(node.Name, out GroupTemplateChannelFields field)) { values[field] = node.InnerText; }
            }

            if (!values.ContainsKey(GroupTemplateChannelFields.MMEChannelId) || !values.ContainsKey(GroupTemplateChannelFields.MMEChannelType)) { return; }


            if (!long.TryParse(values[GroupTemplateChannelFields.MMEChannelId], System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out long id))
            {
                return;
            }
            if (!int.TryParse(values[GroupTemplateChannelFields.MMEChannelType], System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out int cType))
            {
                return;
            }

            MMEPossibleChannels mChannel;

            if (cType == (int)MMEPossibleChannels.MMEChannelTypes.SQL && importChannels.ContainsKey(id))
            {
                mChannel = importChannels[id];
            }
            else { mChannel = ApplicationProperties.IsoDb.GetPossibleChannel(id, cType); }

            if (null == mChannel) { return; }

            var channel = new TestObjectTemplateChannel(mChannel);

            using (var enumeratorGroupChannelFieldSettings = values.GetEnumerator())
            {
                while (enumeratorGroupChannelFieldSettings.MoveNext())
                {
                    switch (enumeratorGroupChannelFieldSettings.Current.Key)
                    {
                        case GroupTemplateChannelFields.BitResolution: break;
                        case GroupTemplateChannelFields.ChannelAmplitudeClass: break;
                        case GroupTemplateChannelFields.ChannelFrequencyClass: break;
                        case GroupTemplateChannelFields.Comments: break;
                        case GroupTemplateChannelFields.Comments1: break;
                        case GroupTemplateChannelFields.CustomerChannelCode: break;
                        case GroupTemplateChannelFields.CutOffFrequency: break;
                        case GroupTemplateChannelFields.DataSource: break;
                        case GroupTemplateChannelFields.DataStatus: break;
                        case GroupTemplateChannelFields.Dimension: break;
                        case GroupTemplateChannelFields.Direction: break;
                        case GroupTemplateChannelFields.DisplayOrder:
                            channel.DisplayOrder = Convert.ToInt32(enumeratorGroupChannelFieldSettings.Current.Value,
                                System.Globalization.CultureInfo.InvariantCulture);
                            break;
                        case GroupTemplateChannelFields.EndOffsetInterval: break;
                        case GroupTemplateChannelFields.FirstGlobalMaximumValue: break;
                        case GroupTemplateChannelFields.FirstGlobalMinimumValue: break;
                        case GroupTemplateChannelFields.LaboratoryChannelCode: break;
                        case GroupTemplateChannelFields.LocalOnly:
                            channel.LocalOnly = Convert.ToBoolean(enumeratorGroupChannelFieldSettings.Current.Value);
                            break;
                        case GroupTemplateChannelFields.Location: break;
                        case GroupTemplateChannelFields.MMEChannelId: break;
                        case GroupTemplateChannelFields.MMEChannelType: break;
                        case GroupTemplateChannelFields.NameOfTheChannel:
                            channel.NameOfTheChannel = enumeratorGroupChannelFieldSettings.Current.Value;
                            break;
                        case GroupTemplateChannelFields.NumberOfSamples: break;
                        case GroupTemplateChannelFields.OffsetPostTest: break;
                        case GroupTemplateChannelFields.PreFilterType: break;
                        case GroupTemplateChannelFields.ReferenceChannel: break;
                        case GroupTemplateChannelFields.ReferenceChannelName: break;
                        case GroupTemplateChannelFields.ReferenceSystem: break;
                        case GroupTemplateChannelFields.Required:
                            channel.Required = Convert.ToBoolean(enumeratorGroupChannelFieldSettings.Current.Value);
                            break;
                        case GroupTemplateChannelFields.SamplingInterval: break;
                        case GroupTemplateChannelFields.StartOffsetInterval: break;
                        case GroupTemplateChannelFields.TestObjectNumber: break;
                        case GroupTemplateChannelFields.TimeOfFirstSample: break;
                        case GroupTemplateChannelFields.TimeOfMaximumValue: break;
                        case GroupTemplateChannelFields.TimeOfMinimumValue: break;
                        case GroupTemplateChannelFields.TransducerDampingRatio: break;
                        case GroupTemplateChannelFields.TransducerId: break;
                        case GroupTemplateChannelFields.TransducerNaturalFrequency: break;
                        case GroupTemplateChannelFields.TransducerType: break;
                        case GroupTemplateChannelFields.Unit: break;
                        default:
                            throw new NotSupportedException(
                                "TestObjectTemplate::ProcessChannelXMLNode unsupported field: " + enumeratorGroupChannelFieldSettings.Current.Key);
                    }
                }
            }
            existingChannels.Add(channel);
            var maxDisplayOrder = (from ch in existingChannels select ch.DisplayOrder).Max();

            foreach (var ch in existingChannels)
            {
                if (-1 == ch.DisplayOrder)
                {
                    ch.DisplayOrder = ++maxDisplayOrder;
                }
            }
            template.Channels = existingChannels.ToArray();
        }

        #endregion
    }
}