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

namespace DatabaseExport
{
    public class TestObjectTemplate
    {
        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
        };
        public const string NON_ISO_TESTOBJECT_CHANNEL_TYPE = "x_NonISOTestObjectType_x";
        public const string NON_ISO_TESTOBJECT_NAME = "x_NonISOTestObjectName_x";
        public string LastModifiedBy { get; set; } = "N/A";

        public DateTime LastModified { get; set; } = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;

        private int _currentZoneIndex = -1;
        public int CurrentZoneIndex
        {
            get => _currentZoneIndex;
            set
            {
                if (value >= 0)
                {
                    CurrentZone = TemplateZones[value];
                }
                else
                {
                    CurrentZone = null;
                }
                _currentZoneIndex = value;
            }
        }

        private Zone _currentZone = null;//Zone.DummyZone;
        public Zone CurrentZone
        {
            get => _currentZone;
            set
            {
                //if (null != _currentZone && _currentZone != value) { _currentZone.PropertyChanged -= CurrentZone_PropertyChanged; }
                _currentZone = value;

                //if (null != _currentZone) { _currentZone.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(CurrentZone_PropertyChanged); }
                if (null == value) { AreZoneControlsEnabled = false; }
                else { AreZoneControlsEnabled = true; }
            }
        }


        public bool AreZoneControlsEnabled { get; set; } = false;

        private ISO.TestObjectTemplate _template = null;
        public List<TestObjectTemplateChannel> RequiredChannels { get; set; } = new List<TestObjectTemplateChannel>();

        public string TemplateParent { get; set; } = "";

        public bool SysBuilt { get; set; } = false;

        private bool _embedded = false;
        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; }
            }
        }

        public string TemplateName { get; set; }

        public string TemplateDescription { get; set; }

        public bool IsLocalOnly { get; set; }

        private MMETestObjects _testObject;
        public MMETestObjects TestObject
        {
            get => _testObject;
            set
            {
                _testObject = value;
                if (null != _testObject)
                {
                    AvailableTestObjectTypes = ISO13499FileDb.IsoDb.GetUniquePossibleChannelTypes(TestObjectTemplateChannel.NONISOCHANNELTYPE);
                    if (AvailableTestObjectTypes.Length > 0) { TestObjectTypeIndex = 0; }
                    else { TestObjectTypeIndex = -1; }
                }
            }
        }

        private string _testObjectType;
        public string TestObjectType
        {
            get => _testObjectType;
            set
            {
                _testObjectType = value;
                //if (null != _template) { _template.TestObjectType = value; }//we did this so that _template.TestObjectType gets set, however during initialization _template can be null
                _channels = new List<MMEPossibleChannels>(ISO13499FileDb.IsoDb.GetPossibleChannelsForType(_testObjectType));
                var all = new List<TestObjectTemplateChannel>();
                var db = ISO13499FileDb.IsoDb;
                foreach (var pc in _channels) { all.Add(new TestObjectTemplateChannel(new TestObjectTemplateChannel(pc), /*ref db,*/ _template)); }
                TemplateAllChannels = all.ToArray();
            }
        }

        private List<MMEPossibleChannels> _channels = new List<MMEPossibleChannels>();

        private List<TestObjectTemplateChannel> _allChannels = new List<TestObjectTemplateChannel>();
        public TestObjectTemplateChannel[] TemplateAllChannels
        {
            get { _allChannels.Sort(new Comparison<TestObjectTemplateChannel>(CompareChannels)); return _allChannels.ToArray(); }
            set
            {
                _allChannels = new List<TestObjectTemplateChannel>(value);

                var channels = new List<TemplateChannelUI>();
                foreach (var c in value)
                {
                    var channel = new TemplateChannelUI(c);
                    channels.Add(channel);
                }
                TemplateAllUIChannels = channels.ToArray();
            }
        }
        private List<TemplateChannelUI> _allUIChannels = new List<TemplateChannelUI>();
        public TemplateChannelUI[] TemplateAllUIChannels
        {
            get => _allUIChannels.ToArray();
            set => _allUIChannels = new List<TemplateChannelUI>(value);
        }

        private List<Zone> _zones = new List<Zone>();
        public Zone[] TemplateZones
        {
            get => _zones.ToArray();
            set { _zones = new List<Zone>(value); var j = CurrentZoneIndex; }
        }
        private List<string> _availableTestObjectTypes = null;
        public string[] AvailableTestObjectTypes
        {
            get
            {
                if (null == _availableTestObjectTypes)
                {
                    if (null == TestObject) { return new string[0]; }
                    _availableTestObjectTypes = new List<string>(ISO13499FileDb.IsoDb.GetTestObjectTypeForTestObject(TestObject.Test_Object));
                }
                return _availableTestObjectTypes.ToArray();
            }
            set => _availableTestObjectTypes = new List<string>(value);
        }
        private int _testObjectTypeIndex = -1;
        public int TestObjectTypeIndex
        {
            get
            {
                if (string.IsNullOrEmpty(TestObjectType)) { return -1; }
                return _availableTestObjectTypes.IndexOf(TestObjectType);
            }
            set
            {
                if (value >= 0) { TestObjectType = _availableTestObjectTypes[value]; }
                else { TestObjectType = null; }
                _testObjectTypeIndex = value;

                var all = new List<TestObjectTemplateChannel>();
                var db = ISO13499FileDb.IsoDb;
                foreach (var pc in _channels) { all.Add(new TestObjectTemplateChannel(new TestObjectTemplateChannel(pc), /*ref db,*/ _template)); }
                TemplateAllChannels = all.ToArray();
            }
        }
        public static MMETestObjects GetNonISOTestObject()
        {
            var existingobjects = ISO13499FileDb.IsoDb.GetTestObjects(false);

            var codes = new List<string>();

            foreach (var existingobject in existingobjects)
            {
                if (existingobject.Text_L1 == NON_ISO_TESTOBJECT_NAME)
                {
                    return existingobject;
                }
                else { codes.Add(existingobject.Test_Object); }
            }

            //first try to find a suitable alpha character that isn't in use
            for (var i = (int)('A'); i <= 'Z'; i++)
            {
                var s = new string(new char[] { (char)i });
                if (!codes.Contains(s))
                {
                    var to = new MMETestObjects(Guid.NewGuid().ToString(), s, NON_ISO_TESTOBJECT_NAME, NON_ISO_TESTOBJECT_NAME, 1,
                        DateTime.Now, "SYSTEM", false, "", DateTime.Now, "created", "", MMEPossibleChannels.MMEChannelTypes.SQL);
                    //ISO13499FileDb.IsoDb.Commit(to);
                    return to;
                }
            }
            //didn't find one, now try for a suitable numeric character
            for (var i = (int)'0'; i <= '9'; i++)
            {
                var s = new string(new char[] { (char)i });
                if (!codes.Contains(s))
                {
                    var to = new MMETestObjects(Guid.NewGuid().ToString(), s, NON_ISO_TESTOBJECT_NAME, NON_ISO_TESTOBJECT_NAME, 1,
                        DateTime.Now, "SYSTEM", false, "", DateTime.Now, "created", "", MMEPossibleChannels.MMEChannelTypes.SQL);
                    //(App.Current as App).IsoDb.Commit(to);
                    return to;
                }
            }
            throw new NotSupportedException("Could not create system Non-ISO Group" /*Strings.StringResources.TestObjectTemplate_CouldNotCreateNONISOTESTOBJECT*/);
        }
        public ISO.TestObjectTemplate ToISOTestObjectTemplate()
        {
            var log = new System.Diagnostics.EventLog();
            log.Source = "DataPROInstaller";

            log.WriteEntry("Getting a new ISO.TestObjectTemplate using " + TemplateName);
            var template = new ISO.TestObjectTemplate(TemplateName, IsLocalOnly);
            log.WriteEntry("Got a new ISO.TestObjectTemplate");
            template.Description = TemplateDescription;
            log.WriteEntry("Set template.Description to " + TemplateDescription);
            template.OriginalTemplateName = OriginalTemplateName;
            log.WriteEntry("Set template.OriginalTemplateName to " + OriginalTemplateName);
            template.Embedded = Embedded;
            log.WriteEntry("Set template.Embedded to " + Embedded);
            template.Icon = "";
            log.WriteEntry("Set template.Icon to " + "");
            template.LocalOnly = IsLocalOnly;
            log.WriteEntry("Set LocalOnly to " + IsLocalOnly);
            if (TestObject == null)
            {
                log.WriteEntry("TestObject is null");
            }
            else if (TestObject.Test_Object == null)
            {
                log.WriteEntry("TestObject.Test_Object is null");
            }
            log.WriteEntry("Setting template.TestObject to " + TestObject.Test_Object);
            template.TestObject = TestObject.Test_Object;
            log.WriteEntry("Set template.TestObject successfully");
            template.TestObjectType = TestObjectType;
            var zones = new List<TemplateZone>();
            foreach (var zone in TemplateZones)
            {
                var isoZone = new TemplateZone(TemplateName, zone.Name, zone.GetPictureName(), zone.Description);

                var zoneRegions = new List<TemplateRegion>();
                var i = 0;
                foreach (var region in zone.Regions)
                {
                    var isoRegion = region.ToISORegion(this, zone, i++);
                    zoneRegions.Add(isoRegion);
                }
                isoZone.TemplateRegions = zoneRegions.ToArray();
                zones.Add(isoZone);
            }
            template.TemplateParent = TemplateParent;
            log.WriteEntry("Setting template.Channels to TemplateAllChannels");
            template.Channels = TemplateAllChannels;
            log.WriteEntry("Set template.Channels successfully");
            template.Zones = zones.ToArray();
            template.SysBuilt = SysBuilt;
            log.WriteEntry("Returning");
            return template;
        }
        private int CompareChannels(TestObjectTemplateChannel left, TestObjectTemplateChannel right)
        {
            if (left == right) { return 0; }
            if (null == left) { return -1; }
            if (null == right) { return 1; }
            return left.DisplayOrder.CompareTo(right.DisplayOrder);
        }
        public TestObjectTemplate(TestObjectTemplate copy, ref ISO13499FileDb db)
        {
            if (null != copy._template) { _template = new 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;
            var channels = new List<TestObjectTemplateChannel>();
            foreach (var c in copy.TemplateAllChannels)
            {
                channels.Add(new TestObjectTemplateChannel(c, /*ref db,*/ _template));
            }
            foreach (var c in copy.RequiredChannels)
            {
                RequiredChannels.Add(new TestObjectTemplateChannel(c, /*ref db,*/ _template));
            }
            TemplateAllChannels = channels.ToArray();

            var zones = new List<Zone>();
            foreach (var z in copy.TemplateZones)
            {
                zones.Add(new Zone(z.ISODllZone, this));
            }
            TemplateZones = zones.ToArray();
            SysBuilt = copy.SysBuilt;
            Embedded = copy.Embedded;
            OriginalTemplateName = copy.OriginalTemplateName;
        }
        public TestObjectTemplate(ISO.TestObjectTemplate template, ref ISO13499FileDb db)
        {
            Initialize(template, ref db, null);
        }
        private void Initialize(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;
                if (matches.Count() > 0)
                {
                    TestObject = matches.First();
                    bFoundTestObject = true;
                }
            }
            if (!bFoundTestObject)
            {
                TestObject = (ISO13499FileDb.IsoDb.GetTestObjectByIso(template.TestObject));
            }
            TestObjectType = template.TestObjectType;
            OriginalTemplateName = template.OriginalTemplateName;
            Embedded = template.Embedded;

            var channels = new List<TestObjectTemplateChannel>();
            foreach (var c in template.Channels)
            {
                channels.Add(new TestObjectTemplateChannel(c, /*ref db,*/ _template));
            }
            TemplateAllChannels = channels.ToArray();
            TemplateZones = template.Zones.Select(z => new Zone(z, this)).ToArray();
            TemplateParent = template.TemplateParent;
            SysBuilt = template.SysBuilt;
        }
        public TestObjectTemplate()
        {
            TemplateName = string.Empty;
            TemplateDescription = string.Empty;
            TemplateParent = string.Empty;


            switch (SerializedSettings.ISOSupportLevel)
            {
                case SerializedSettings.ISOSupportLevels.ISO_ONLY:
                    TestObject = ISO13499FileDb.IsoDb.GetTestObjects(false).FirstOrDefault();
                    break;
                case SerializedSettings.ISOSupportLevels.NO_ISO:
                    //need to create a template just for this object!
                    InitializeNonISO();
                    break;
                case SerializedSettings.ISOSupportLevels.TRANSITORY:
                    TestObject = ISO13499FileDb.IsoDb.GetTestObjects(false).FirstOrDefault();
                    break;
            }
        }
        private void InitializeNonISO()
        {
            //create template, set template channel type to NONISOTYPE
            TemplateName = (Guid.NewGuid()).ToString();

            TestObject = GetNonISOTestObject();
            TestObjectType = NON_ISO_TESTOBJECT_CHANNEL_TYPE;
        }
        public Dictionary<string, string> GetValues()
        {
            var elementNameValuePairs = new Dictionary<string, string>();
            var isoTemplate = ToISOTestObjectTemplate();

            elementNameValuePairs[GroupTemplateFields.TemplateName.ToString()] = isoTemplate.TemplateName;
            elementNameValuePairs[GroupTemplateFields.Icon.ToString()] = isoTemplate.Icon;
            elementNameValuePairs[GroupTemplateFields.Description.ToString()] = isoTemplate.Description;
            elementNameValuePairs[GroupTemplateFields.LocalOnly.ToString()] = isoTemplate.LocalOnly.ToString();
            elementNameValuePairs[GroupTemplateFields.Version.ToString()] = isoTemplate.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[GroupTemplateFields.LastModifiedBy.ToString()] = /*isoTemplate.*/LastModifiedBy;
            elementNameValuePairs[GroupTemplateFields.LastModified.ToString()] = /*isoTemplate.*/LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[GroupTemplateFields.CRC32.ToString()] = isoTemplate.CRC32.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[GroupTemplateFields.TestObjectType.ToString()] = isoTemplate.TestObjectType;
            elementNameValuePairs[GroupTemplateFields.TestObject.ToString()] = isoTemplate.TestObject;
            elementNameValuePairs[GroupTemplateFields.ParentTemplate.ToString()] = isoTemplate.TemplateParent;
            elementNameValuePairs[GroupTemplateFields.SysBuilt.ToString()] = isoTemplate.SysBuilt.ToString();
            elementNameValuePairs[GroupTemplateFields.OriginalTemplateName.ToString()] = isoTemplate.OriginalTemplateName;
            elementNameValuePairs[GroupTemplateFields.Embedded.ToString()] = isoTemplate.Embedded.ToString(System.Globalization.CultureInfo.InvariantCulture);

            return elementNameValuePairs;
        }
        public Dictionary<string, string> GetTemplateChannelValues(TestObjectTemplateChannel channel)
        {
            var elementNameValuePairs = new Dictionary<string, string>();

            elementNameValuePairs[GroupTemplateChannelFields.TestObjectNumber.ToString()] = channel.TestObjectNumber;
            elementNameValuePairs[GroupTemplateChannelFields.NameOfTheChannel.ToString()] = channel.NameOfTheChannel;
            elementNameValuePairs[GroupTemplateChannelFields.LaboratoryChannelCode.ToString()] = channel.LaboratoryCode;
            elementNameValuePairs[GroupTemplateChannelFields.CustomerChannelCode.ToString()] = channel.CustomerChannelCode;
            elementNameValuePairs[GroupTemplateChannelFields.Comments1.ToString()] = channel.Comments2;
            elementNameValuePairs[GroupTemplateChannelFields.Location.ToString()] = channel.Location;
            elementNameValuePairs[GroupTemplateChannelFields.Dimension.ToString()] = channel.Dimension;
            elementNameValuePairs[GroupTemplateChannelFields.Direction.ToString()] = channel.Direction;
            elementNameValuePairs[GroupTemplateChannelFields.ChannelFrequencyClass.ToString()] = channel.ChannelFrequencyClass;
            elementNameValuePairs[GroupTemplateChannelFields.Unit.ToString()] = channel.Unit;
            elementNameValuePairs[GroupTemplateChannelFields.ReferenceSystem.ToString()] = channel.ReferenceSystem;
            elementNameValuePairs[GroupTemplateChannelFields.TransducerType.ToString()] = channel.TransducerType;
            elementNameValuePairs[GroupTemplateChannelFields.TransducerId.ToString()] = channel.TransducerId;
            elementNameValuePairs[GroupTemplateChannelFields.PreFilterType.ToString()] = channel.PreFilterType;
            elementNameValuePairs[GroupTemplateChannelFields.CutOffFrequency.ToString()] = channel.CutOffFrequency;
            elementNameValuePairs[GroupTemplateChannelFields.ChannelAmplitudeClass.ToString()] = channel.ChannelAmplitudeClass;
            elementNameValuePairs[GroupTemplateChannelFields.ReferenceChannel.ToString()] = channel.ReferenceChannel.ToString();
            elementNameValuePairs[GroupTemplateChannelFields.ReferenceChannelName.ToString()] = channel.ReferenceChannelName;
            elementNameValuePairs[GroupTemplateChannelFields.DataSource.ToString()] = channel.DataSource.ToString();
            elementNameValuePairs[GroupTemplateChannelFields.DataStatus.ToString()] = channel.DataStatus.ToString();
            elementNameValuePairs[GroupTemplateChannelFields.SamplingInterval.ToString()] = channel.SamplingInterval;
            elementNameValuePairs[GroupTemplateChannelFields.BitResolution.ToString()] = channel.BitResolution;
            elementNameValuePairs[GroupTemplateChannelFields.TimeOfFirstSample.ToString()] = channel.TimeOfFirstSample;
            elementNameValuePairs[GroupTemplateChannelFields.NumberOfSamples.ToString()] = channel.NumberOfSamples;
            elementNameValuePairs[GroupTemplateChannelFields.OffsetPostTest.ToString()] = channel.OffsetPostTest;
            elementNameValuePairs[GroupTemplateChannelFields.TransducerNaturalFrequency.ToString()] = channel.TransducerNaturalFrequency;
            elementNameValuePairs[GroupTemplateChannelFields.TransducerDampingRatio.ToString()] = channel.TransducerDampingRatio;
            elementNameValuePairs[GroupTemplateChannelFields.Comments.ToString()] = channel.Comments1;
            elementNameValuePairs[GroupTemplateChannelFields.FirstGlobalMaximumValue.ToString()] = channel.FirstGlobalMaximumValue;
            elementNameValuePairs[GroupTemplateChannelFields.TimeOfMaximumValue.ToString()] = channel.TimeOfMaximumValue;
            elementNameValuePairs[GroupTemplateChannelFields.FirstGlobalMinimumValue.ToString()] = channel.FirstGlobalMinimumValue;
            elementNameValuePairs[GroupTemplateChannelFields.TimeOfMinimumValue.ToString()] = channel.TimeOfMinimumValue;
            elementNameValuePairs[GroupTemplateChannelFields.StartOffsetInterval.ToString()] = channel.StartOffsetInterval;
            elementNameValuePairs[GroupTemplateChannelFields.EndOffsetInterval.ToString()] = channel.EndOffsetInterval;
            elementNameValuePairs[GroupTemplateChannelFields.MMEChannelId.ToString()] = channel.Channel.Id.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[GroupTemplateChannelFields.MMEChannelType.ToString()] = channel.Channel.MMEChannelType.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[GroupTemplateChannelFields.Required.ToString()] = channel.Required.ToString();
            elementNameValuePairs[GroupTemplateChannelFields.DisplayOrder.ToString()] = channel.DisplayOrder.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[GroupTemplateChannelFields.LocalOnly.ToString()] = channel.LocalOnly.ToString();

            return elementNameValuePairs;
        }
    }
}