using DTS.Common.XMLUtils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

namespace DTS.Common.ISO
{

    public class TestPlan : IXmlSerializable
    {
        /// <summary>
        /// part of IXmlSerializable - from MS documentation this should return null
        /// when implementing IXmlSerializable
        /// https://learn.microsoft.com/en-us/dotnet/api/system.xml.serialization.ixmlserializable.getschema?view=net-9.0
        /// </summary>
        public XmlSchema GetSchema() { return null; }
        /// <summary>
        /// deserializes class from xml
        /// </summary>
        public void ReadXml(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("TestPlan::ReadXml - XmlReader was null"); }
            reader.ReadStartElement("TestPlan");

            ReadFields(reader);
            ReadTestObjects(reader);
            ReadExtraProperties(reader);
            ReadTestObjectFiles(reader);

            reader.ReadEndElement();
        }
        /// <summary>
        /// serializes class to xml
        /// </summary>
        public void WriteXml(XmlWriter writer)
        {
            if (null == writer) { throw new ArgumentException("TestPlan::WriteXml - XmlWriter was null"); }
            writer.WriteStartElement("TestPlan");
            writer.WriteAttributeString("Version", "1");
            WriteFields(writer);
            WriteTestObjects(writer);
            WriteExtraProperties(writer);
            WriteTestObjectFiles(writer);

            writer.WriteEndElement();
        }
        private void ReadExtraProperties(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("TestPlan::ReadExtraProperties - XmlReader was null"); }
            var properties = new List<KeyValuePair<string, string>>();

            if (reader.Name == "ExtraProperties" && reader.IsEmptyElement) { reader.Read(); }
            else
            {
                reader.ReadStartElement("ExtraProperties");

                while (reader.IsStartElement("ExtraProperty"))
                {

                    var key = reader.GetAttribute("Key");
                    var value = reader.GetAttribute("Value");

                    properties.Add(new KeyValuePair<string, string>(key, value));

                    reader.Read();
                }

                reader.ReadEndElement();
            }
            ExtraProperties = properties.ToArray();
        }
        private void WriteExtraProperties(XmlWriter writer)
        {
            if (null == writer) { throw new ArgumentException("TestPlan::WriteExtraProperties - XmlWriter was null"); }
            writer.WriteStartElement("ExtraProperties");

            foreach (var property in ExtraProperties)
            {
                writer.WriteStartElement("ExtraProperty");

                writer.WriteAttributeString("Key", property.Key);
                writer.WriteAttributeString("Value", property.Value);

                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }
        private void ReadTestObjects(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("TestPlan::ReadTestObjects - XmlReader was null"); }
            reader.ReadStartElement("TestObjects");

            var list = new List<MMETestObjectWrapper>();
            while (reader.IsStartElement() && reader.Name == "TestObject")
            {
                var wrapper = new MMETestObjectWrapper();
                wrapper.ReadXml(reader);
                if (!Array.Exists(ISOTestObjects, x => x.TypeOfTestObject.Equals(wrapper.TypeOfTestObject)))
                {
                    //if the test object from the xml file doesn't exist in the test, ignore it.
                    //this is the case where the xml file contains test objects not in the test
                    continue;
                }
                list.Add(wrapper);
            }
            //now for any test objects in the test that _aren't_ in the xml, add them to the list
            //this is the case where the test has test objects not in the xml
            var existingObjectsNotInXml = from existingTestObject in ISOTestObjects where !list.Exists(y => y.TypeOfTestObject.Equals(existingTestObject.TypeOfTestObject)) select existingTestObject;
            if (existingObjectsNotInXml.Any())
            {
                foreach (var existingObject in existingObjectsNotInXml)
                {
                    list.Add(existingObject);
                }
            }

            ISOTestObjects = list.ToArray();
            reader.ReadEndElement();
        }
        private void WriteTestObjects(XmlWriter writer)
        {
            if (null == writer) { throw new ArgumentException("TestPlan::WriteTestObjects - XmlWriter was null"); }
            writer.WriteStartElement("TestObjects");

            if (null != ISOTestObjects)
            {
                foreach (var obj in ISOTestObjects)
                {
                    obj.WriteXml(writer);
                }
            }

            writer.WriteEndElement();
        }

        private void ReadTestObjectFiles(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("TestPlan::ReadTestObjectFiles - XmlReader was null"); }
            var list = new List<string>();
            if (reader.IsEmptyElement) { reader.Read(); }
            else
            {
                reader.ReadStartElement("ISOFiles");

                while (reader.IsStartElement() && reader.Name == "File")
                {
                    list.Add(DTSXMLFile.GetInnerXML(reader));
                }

                reader.ReadEndElement();
            }
            TestObjectFiles = list.ToArray();
        }
        private void WriteTestObjectFiles(XmlWriter writer)
        {
            if (null == writer) { throw new ArgumentException("TestPlan::WriteTestObjectFiles - XmlWriter was null"); }
            writer.WriteStartElement("ISOFiles");

            foreach (var file in IsoTestObjectFiles)
            {
                writer.WriteStartElement("File");
                writer.WriteString(file);
                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }
        
        private void ReadFields(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("TestPlan::ReadFields - XmlReader was null"); }
            if (reader.Name != "Fields") { throw new XmlException("Invalid XML"); }
            var fields = Enum.GetValues(typeof(IsoFields)).Cast<IsoFields>().ToArray();
            foreach (var field in fields)
            {
                //skip title since it comes from the setup name, we probably don't want to overwrite it
                if (field == IsoFields.Title) { continue; }
                SetField(field, reader.GetAttribute(field.ToString()));
            }
            //it's all in one element, so read the start and end element all in one
            reader.ReadStartElement("Fields");
        }

        private void WriteFields(XmlWriter writer)
        {
            if (null == writer) { throw new ArgumentException("TestPlan::WriteFields - XmlWriter was null"); }
            writer.WriteStartElement("Fields");

            var fields = Enum.GetValues(typeof(IsoFields)).Cast<IsoFields>().ToArray();
            foreach (var field in fields)
            {
                writer.WriteAttributeString(field.ToString(), GetField(field));
            }

            writer.WriteEndElement();
        }

        public string Name { get; set; } = "New Test Plan";

        public string Description { get; set; } = "New Test";

        public DateTime InceptionDate { get; } = DateTime.Now;

        public string[] TestObjectFiles { get; set; } = new string[0];

        public MMETestObjectWrapper[] ISOTestObjects { get; set; } = new MMETestObjectWrapper[0];

        private LabratoryDetails _lab;
        private LabratoryDetails GetLabratoryDetails()
        {
            return _lab ?? (_lab = new LabratoryDetails());
        }

        private CustomerDetails _customer;
        private CustomerDetails GetCustomer()
        {
            return _customer ?? (_customer = new CustomerDetails());
        }

        private TestEngineerDetails _testEngineer;
        private TestEngineerDetails GetTestEngineer()
        {
            return _testEngineer ?? (_testEngineer = new TestEngineerDetails());
        }

        public string Title { get; set; } = "NOVALUE";

        public string MediaNumber { get; set; }

        public string TypeOfTest { get; set; } = "NOVALUE";

        public string SubTypeofTest { get; set; } = "NOVALUE";

        public string Regulation { get; set; } = "NOVALUE";

        public string ReferenceTemperature { get; set; } = "NOVALUE";

        public string RelativeAirHumidity { get; set; } = "NOVALUE";

        public string DateOfTest { get; set; } = "NOVALUE";

        public string TestComment { get; set; } = "NOVALUE";

        public KeyValuePair<string, string>[] ExtraProperties { get; set; } = new KeyValuePair<string, string>[0];

        public string[] IsoTestObjectFiles { get; set; } = new string[0];


        public enum IsoFields
        {
            CustName,
            CustomerCostUnit,
            CustomerName,
            CustomerOrderNumber,
            CustomerProjectReferenceNumber,
            TEName,
            TestEngineerEmail,
            TestEngineerFax,
            TestEngineerName,
            TestEngineerPhone,
            CustomerTestReferenceNumber,
            Date,
            ExtraProperties,
            LabName,
            LaboratoryContactEmail,
            LaboratoryContactFax,
            LaboratoryContactName,
            LaboratoryContactPhone,
            LaboratoryName,
            LaboratoryTestReferenceNumber,
            LaboratoryProjectReferenceNumber,
            NumberOfMedia,
            NumberOfTestObjects,
            ReferenceTemperature,
            Regulation,
            RelativeAirHumidity,
            Subtype,
            TestComment,
            Title,
            Type
        }

        public string NumberOfMedia { get; set; }


        public string NumberOfTestObjects => ISOTestObjects.Length.ToString();

        public string GetField(IsoFields field)
        {
            switch (field)
            {
                case IsoFields.CustName:
                    return GetCustomer().Name;
                case IsoFields.CustomerCostUnit:
                    return GetCustomer().CustomerCostUnit;
                case IsoFields.CustomerName:
                    return GetCustomer().CustomerName;
                case IsoFields.CustomerOrderNumber:
                    return GetCustomer().CustomerOrderNumber;
                case IsoFields.CustomerProjectReferenceNumber:
                    return GetCustomer().ProjectRefNumber;
                case IsoFields.TEName:
                    return GetTestEngineer().Name;
                case IsoFields.TestEngineerEmail:
                    return GetTestEngineer().TestEngineerEmail;
                case IsoFields.TestEngineerFax:
                    return GetTestEngineer().TestEngineerFax;
                case IsoFields.TestEngineerName:
                    return GetTestEngineer().TestEngineerName;
                case IsoFields.TestEngineerPhone:
                    return GetTestEngineer().TestEngineerPhone;
                case IsoFields.CustomerTestReferenceNumber:
                    return GetCustomer().CustomerTestRefNumber;
                case IsoFields.Date:
                    return DateOfTest;
                case IsoFields.LabName:
                    return GetLabratoryDetails().Name;
                case IsoFields.LaboratoryContactEmail:
                    return GetLabratoryDetails().LabratoryContactEmail;
                case IsoFields.LaboratoryContactFax:
                    return GetLabratoryDetails().LabratoryContactFax;
                case IsoFields.LaboratoryContactName:
                    return GetLabratoryDetails().LabratoryContactName;
                case IsoFields.LaboratoryContactPhone:
                    return GetLabratoryDetails().LabratoryContactPhone;
                case IsoFields.LaboratoryName:
                    return GetLabratoryDetails().LabratoryName;
                case IsoFields.LaboratoryTestReferenceNumber:
                    return GetLabratoryDetails().LabratoryTestRefNumber;
                case IsoFields.LaboratoryProjectReferenceNumber:
                    return GetLabratoryDetails().LabratoryProjectRefNumber;
                case IsoFields.NumberOfMedia:
                    return NumberOfMedia;
                case IsoFields.NumberOfTestObjects:
                    return NumberOfTestObjects;
                case IsoFields.ReferenceTemperature:
                    return ReferenceTemperature;
                case IsoFields.Regulation:
                    return Regulation;
                case IsoFields.RelativeAirHumidity:
                    return RelativeAirHumidity;
                case IsoFields.Subtype:
                    return SubTypeofTest;
                case IsoFields.TestComment:
                    return TestComment;
                case IsoFields.Title:
                    return Title;
                case IsoFields.Type:
                    return TypeOfTest;
                default:
                    return "NOVALUE";
            }
        }

        public void SetField(IsoFields field, string value)
        {
            if (string.IsNullOrEmpty(value)) { return; }
            switch (field)
            {
                case IsoFields.CustName:
                    GetCustomer().Name = value;
                    break;
                case IsoFields.CustomerCostUnit:
                    GetCustomer().CustomerCostUnit = value;
                    break;
                case IsoFields.CustomerName:
                    GetCustomer().CustomerName = value;
                    break;
                case IsoFields.CustomerOrderNumber:
                    GetCustomer().CustomerOrderNumber = value;
                    break;
                case IsoFields.CustomerProjectReferenceNumber:
                    GetCustomer().ProjectRefNumber = value;
                    break;
                case IsoFields.TEName:
                    GetTestEngineer().Name = value;
                    break;
                case IsoFields.TestEngineerEmail:
                    GetTestEngineer().TestEngineerEmail = value;
                    break;
                case IsoFields.TestEngineerFax:
                    GetTestEngineer().TestEngineerFax = value;
                    break;
                case IsoFields.TestEngineerName:
                    GetTestEngineer().TestEngineerName = value;
                    break;
                case IsoFields.TestEngineerPhone:
                    GetTestEngineer().TestEngineerPhone = value;
                    break;
                case IsoFields.CustomerTestReferenceNumber:
                    GetCustomer().CustomerTestRefNumber = value;
                    break;
                case IsoFields.Date:
                    DateOfTest = value;
                    break;
                case IsoFields.ExtraProperties:
                    break;
                case IsoFields.LabName:
                    GetLabratoryDetails().Name = value;
                    break;
                case IsoFields.LaboratoryContactEmail:
                    GetLabratoryDetails().LabratoryContactEmail = value;
                    break;
                case IsoFields.LaboratoryContactFax:
                    GetLabratoryDetails().LabratoryContactFax = value;
                    break;
                case IsoFields.LaboratoryContactName:
                    GetLabratoryDetails().LabratoryContactName = value;
                    break;
                case IsoFields.LaboratoryContactPhone:
                    GetLabratoryDetails().LabratoryContactPhone = value;
                    break;
                case IsoFields.LaboratoryName:
                    GetLabratoryDetails().LabratoryName = value;
                    break;
                case IsoFields.LaboratoryTestReferenceNumber:
                    GetLabratoryDetails().LabratoryTestRefNumber = value;
                    break;
                case IsoFields.LaboratoryProjectReferenceNumber:
                    GetLabratoryDetails().LabratoryProjectRefNumber = value;
                    break;
                case IsoFields.NumberOfMedia:
                    NumberOfMedia = value;
                    break;
                case IsoFields.NumberOfTestObjects:
                    break;
                case IsoFields.ReferenceTemperature:
                    ReferenceTemperature = value;
                    break;
                case IsoFields.Regulation:
                    Regulation = value;
                    break;
                case IsoFields.RelativeAirHumidity:
                    RelativeAirHumidity = value;
                    break;
                case IsoFields.Subtype:
                    SubTypeofTest = value;
                    break;
                case IsoFields.TestComment:
                    TestComment = value;
                    break;
                case IsoFields.Title:
                    Title = value;
                    break;
                case IsoFields.Type:
                    TypeOfTest = value;
                    break;
                default:
                    throw new NotSupportedException("unknown iso field " + field);
            }
        }
    }
}