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

namespace DTS.Common.ISO
{
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Minor Code Smell", "S101:Types should be named in PascalCase", Justification = "Acronym")]
    public class MMETestObjectWrapper : 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>
        /// writes an element with a text value into xml
        /// this is used for adding properties into the xml body for the class
        /// </summary>
        private void WriteField(XmlWriter writer, string field, string value)
        {
            if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteField - writer was null"); }
            if (string.IsNullOrEmpty(field)) { return; } //nothing to add
            writer.WriteStartElement(field);
            writer.WriteString(value);
            writer.WriteEndElement();
        }
        /// <summary>
        /// serializes class to xml
        /// </summary>
        public void WriteXml(XmlWriter writer)
        {
            if (null == writer)
            {
                throw new ArgumentException("MMETestObjectWrapper::WriteXml - XmlWriter was null");
            }
            writer.WriteStartElement("TestObject");
            WriteField(writer, "BarrierHeightOfTestObject", BarrierHeightOfTestObject);
            WriteField(writer, "BarrierWidthOfTestObject", BarrierWidthOfTestObject);
            WriteField(writer, "ClassOfTestObject", ClassOfTestObject);
            WriteField(writer, "CodeOfTestObject", CodeOfTestObject);
            WriteField(writer, "DriverPosition", DriverPosition);
            WriteField(writer, "File", File);
            WriteField(writer, "ImpactSide", ImpactSide);
            WriteField(writer, "MMETestObjectGUID", MMETestObjectGUID);
            WriteField(writer, "MassOfTestObject", MassOfTestObject);
            WriteField(writer, "Name", Name);
            WriteField(writer, "NumberOfLoadcellsOfTestObject", NumberOfLoadcellsOfTestObject);
            WriteField(writer, "OffsetOfTestObject", OffsetOfTestObject);
            WriteField(writer, "OriginXOfTestObject", OriginXOfTestObject);
            WriteField(writer, "OriginYOfTestObject", OriginYOfTestObject);
            WriteField(writer, "OriginZOfTestObject", OriginZOfTestObject);
            WriteField(writer, "ReferenceNumberOfTestObject", ReferenceNumberOfTestObject);
            WriteField(writer, "ReferenceSystemOfTestObject", ReferenceSystemOfTestObject);
            WriteField(writer, "TypeOfTestObject", TypeOfTestObject);
            WriteField(writer, "Velocity", Velocity);
            WriteField(writer, "VelocityMeasurementUnit", VelocityMeasurementUnit);
            WriteField(writer, "YawAngleOfTestObject", YawAngleOfTestObject);

            WriteComments(writer);
            WriteISOTestObjectChannels(writer);

            WriteExtraProperties(writer);
            writer.WriteEndElement();
        }
        private void WriteISOTestObjectChannels(XmlWriter writer)
        {
            if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteISOTestObjectChannels - writer was null"); }
            writer.WriteStartElement("Channels");

            if (null != ISOTestObjectChannels)
            {
                foreach (var channel in ISOTestObjectChannels)
                {
                    writer.WriteStartElement("Channel");
                    writer.WriteString(channel);
                    writer.WriteEndElement();
                }
            }
            writer.WriteEndElement();
        }
        private void ReadISOTestObjectChannels(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadISOTestObjectChannels - reader was null"); }
            var channels = new List<string>();
            //if the element tag is empty there's nothing else to process, move to next node
            if (reader.Name == "Channels" && reader.IsEmptyElement) { reader.Read(); }
            else
            {
                reader.ReadStartElement("Channels");

                while (reader.IsStartElement() && reader.Name == "Channel")
                {
                    channels.Add(DTSXMLFile.GetInnerXML(reader));
                    reader.Read();
                }

                ISOTestObjectChannels = channels.ToArray();

                reader.ReadEndElement();
            }
        }
        private void ReadComments(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadComments - XmlReader was null"); }
            var comments = new List<string>();
            //if top level element is empty, nothing to process, just move to next node
            if (reader.IsEmptyElement && reader.Name == "Comments") { reader.Read(); }
            else
            {
                reader.ReadStartElement("Comments");

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

                reader.ReadEndElement();
            }
            Comments = comments.ToArray();
        }
        private void WriteComments(XmlWriter writer)
        {
            if (null == writer) { throw new ArgumentException("MMETestObjectWrapper::WriteComments - XmlWriter was null"); }
            writer.WriteStartElement("Comments");
            foreach( var comment in Comments)
            {
                writer.WriteStartElement("Comment");
                writer.WriteString(comment);
                writer.WriteEndElement();
            }
            writer.WriteEndElement();
        }
        private void ReadExtraProperties(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadExtraProperties - XmlReader was null"); }
            var list = new List<KeyValuePair<string, string>>();
            if (reader.Name == "ExtraProperties" && reader.IsEmptyElement) { reader.Read(); }
            else
            {
                reader.ReadStartElement("ExtraProperties");

                while (reader.IsStartElement() && reader.Name == "ExtraProperty")
                {
                    var key = reader.GetAttribute("Key");
                    var value = reader.GetAttribute("Value");
                    list.Add(new KeyValuePair<string, string>(key, value));
                    reader.Read();
                }

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

            if (null != ExtraProperties)
            {
                foreach( var kvp in ExtraProperties)
                {
                    writer.WriteStartElement("ExtraProperty");

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

                    writer.WriteEndElement();
                }
            }

            writer.WriteEndElement();
        }
        
        public void ReadXml(XmlReader reader)
        {
            if (null == reader) { throw new ArgumentException("MMETestObjectWrapper::ReadXml - XmlReader was null"); }
            reader.ReadStartElement("TestObject");
            while (reader.IsStartElement())
            {
                switch (reader.Name)
                {
                    case "BarrierHeightOfTestObject":
                        BarrierHeightOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "BarrierWidthOfTestObject":
                        BarrierWidthOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "ClassOfTestObject":
                        ClassOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "CodeOfTestObject":
                        CodeOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "DriverPosition":
                        DriverPosition = DTSXMLFile.GetInnerXML(reader); break;
                    case "File":
                        File = DTSXMLFile.GetInnerXML(reader); break;
                    case "ImpactSide":
                        ImpactSide = DTSXMLFile.GetInnerXML(reader); break;
                    case "MMETestObjectGUID":
                        MMETestObjectGUID = DTSXMLFile.GetInnerXML(reader); break;
                    case "MassOfTestObject":
                        MassOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "Name":
                        Name = DTSXMLFile.GetInnerXML(reader); break;
                    case "NumberOfLoadcellsOfTestObject":
                        NumberOfLoadcellsOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "OffsetOfTestObject":
                        OffsetOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "OriginXOfTestObject":
                        OriginXOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "OriginYOfTestObject":
                        OriginYOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "OriginZOfTestObject":
                        OriginZOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "ReferenceNumberOfTestObject":
                        ReferenceNumberOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "ReferenceSystemOfTestObject":
                        ReferenceSystemOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "TypeOfTestObject":
                        TypeOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "Velocity":
                        Velocity = DTSXMLFile.GetInnerXML(reader); break;
                    case "VelocityMeasurementUnit":
                        VelocityMeasurementUnit = DTSXMLFile.GetInnerXML(reader); break;
                    case "YawAngleOfTestObject":
                        YawAngleOfTestObject = DTSXMLFile.GetInnerXML(reader); break;
                    case "Comments":
                        ReadComments(reader);
                        break;
                    case "Channels":
                        ReadISOTestObjectChannels(reader);
                        break;
                    case "ExtraProperties":
                        ReadExtraProperties(reader);
                        break;
                    default:
                        throw new ArgumentException($"MMETestObjectWrapper::ReadXml - invalid node - {reader.Name}");
                }
            }
            //end of TestObject element
            reader.ReadEndElement();
        }
        public string GetDirectory() { return "Test Objects"; }

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

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

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

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

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

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

        public string File { get; set; } = "Not Saved Yet";

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

        public string[] ISOTestObjectChannels { get; set; }

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

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

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

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

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

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

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

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

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

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

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

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

        public string VelocityMeterPerSecond => ConvertVelocityToMeterPerSecond(Velocity, VelocityMeasurementUnit);

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

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

        /// <summary>
        /// Convert Velocity to m/sec unit
        /// </summary>
        /// <param name="velocity"></param>
        /// <param name="velocityUnit">VelocityUnit enum index</param>
        /// <returns>Velocity in m/sec</returns>
        private string ConvertVelocityToMeterPerSecond(string velocity, string velocityUnit)
        {
            if (velocity == "NOVALUE" || velocityUnit == "NOVALUE")
            {
                return velocity;
            }

            if ((DTS.Common.Enums.VelocityUnit)Convert.ToInt32(velocityUnit) == Enums.VelocityUnit.KilometerPerHour)
            {
                return (Convert.ToDouble(velocity) / 3.6).ToString();
            }
            return velocity;
        }

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


        public MMETestObjectWrapper()
        {
        }

        public MMETestObjectWrapper(string location)
        {
            if (!location.Contains(Path.DirectorySeparatorChar) && !location.Contains(Path.AltDirectorySeparatorChar))
            {
                var dir = Path.Combine(Environment.CurrentDirectory, GetDirectory());
                location = Path.Combine(dir, location);
            }
            File = location;
            var serializer = new XmlSerializer(typeof(MMETestObjectWrapper));
            using (TextReader tr = new StreamReader(location))
            {
                var cd = (MMETestObjectWrapper)serializer.Deserialize(tr);
                ClassOfTestObject = cd.ClassOfTestObject;
                CodeOfTestObject = cd.CodeOfTestObject;
                Comments = cd.Comments;
                DriverPosition = cd.DriverPosition;
                ExtraProperties = cd.ExtraProperties;
                File = cd.File;
                ImpactSide = cd.ImpactSide;
                MassOfTestObject = cd.MassOfTestObject;
                MMETestObjectGUID = cd.MMETestObjectGUID;
                Name = cd.Name;
                ReferenceNumberOfTestObject = cd.ReferenceNumberOfTestObject;
                Velocity = cd.Velocity;
                VelocityMeasurementUnit = cd.VelocityMeasurementUnit;
                OffsetOfTestObject = cd.OffsetOfTestObject;
                BarrierWidthOfTestObject = cd.BarrierWidthOfTestObject;
                BarrierHeightOfTestObject = cd.BarrierHeightOfTestObject;
                YawAngleOfTestObject = cd.YawAngleOfTestObject;
                ReferenceSystemOfTestObject = cd.ReferenceSystemOfTestObject;
                OriginXOfTestObject = cd.OriginXOfTestObject;
                OriginYOfTestObject = cd.OriginYOfTestObject;
                OriginZOfTestObject = cd.OriginZOfTestObject;
                NumberOfLoadcellsOfTestObject = cd.NumberOfLoadcellsOfTestObject;

                tr.Close();
            }
        }
    }
}