using System;
using System.Xml;


namespace DTS.DASLib.Service
{
    public class XMLHelper
    {
        public static System.Globalization.CultureInfo InvariantCulture = new System.Globalization.CultureInfo("");

        public static string GetString(XmlReader reader)
        {
            if (reader.NodeType != XmlNodeType.Element)
            {
                throw new XmlException("XMLHelper.ReadElement: current node isn't an Element");
            }
            if (reader.IsEmptyElement)
            {
                return string.Empty;
            }
            var thisName = reader.Name;
            if (!reader.Read())
            {
                throw new XmlException("XMLHelper.ReadElement: EOF");
            }
            if (reader.NodeType == XmlNodeType.EndElement) { return string.Empty; }
            if (reader.NodeType != XmlNodeType.Text)
            {
                throw new XmlException("XMLHelper.ReadElement: current Element doesn't have text");
            }
            var value = reader.Value;
            if (!reader.Read())
            {
                throw new XmlException("XMLHelper.ReadElement: EOF");
            }
            if (reader.NodeType != XmlNodeType.EndElement)
            {
                throw new XmlException("XMLHelper.ReadElement: current Element doesn't have an EndElement");
            }
            return value;
        }

        public static string TryGetString(XmlReader reader, string defaultValue)
        {
            try
            {
                return GetString(reader);
            }
            catch 
            {
                return defaultValue;
            }
        }

        public static double GetDouble(XmlReader reader)
        {
            var elemName = reader.Name;
            var value = GetString(reader);
            double result;
            if (!double.TryParse(value, System.Globalization.NumberStyles.Float, InvariantCulture, out result))
            {
                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
            }
            return result;
        }

        public static double TryGetDouble(XmlReader reader, double defaultValue)
        {
            try
            {
                double result;
                if (!double.TryParse(GetString(reader), System.Globalization.NumberStyles.Float, InvariantCulture, out result))
                {
                    return defaultValue;
                }
                return result;
            }
            catch
            {
                return defaultValue;
            }
        }

        public static float GetFloat(XmlReader reader)
        {
            var elemName = reader.Name;
            var value = GetString(reader);
            float result;
            if (!float.TryParse(value, System.Globalization.NumberStyles.Float, InvariantCulture, out result))
            {
                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
            }
            return result;
        }

        public static int GetInt(XmlReader reader)
        {
            var elemName = reader.Name;
            var value = GetString(reader);
            int result;
            if (!int.TryParse(value, System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
            {
                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
            }
            return result;
        }

        public static int TryGetInt(XmlReader reader, int defaultValue)
        {
            try
            {
                int result;
                if (!int.TryParse(GetString(reader), System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
                {
                    return defaultValue;
                }
                return result;
            }
            catch
            {
                return defaultValue;
            }
        }
        /// <summary>
        /// reads a long from xmlreader, throws an exception if there's an issue
        /// </summary>
        public static long GetInt64(XmlReader reader)
        {
            var elemName = reader.Name;
            var value = GetString(reader);
            long result;
            if (!long.TryParse(value, System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
            {
                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
            }
            return result;
        }
        public static uint GetUInt(XmlReader reader)
        {
            var elemName = reader.Name;
            var value = GetString(reader);
            uint result;
            if (!uint.TryParse(value, System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
            {
                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
            }
            return result;
        }

        public static UInt64 GetUInt64(XmlReader reader)
        {
            var elemName = reader.Name;
            var value = GetString(reader);
            UInt64 result;
            if (!UInt64.TryParse(value, System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
            {
                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
            }
            return result;
        }

        public static double? GetOptionalDouble(XmlReader reader)
        {
            var elemName = reader.Name;
            if (reader.HasAttributes)
            {
                var attr = reader.GetAttribute("xsi:nil");
                if (!string.IsNullOrEmpty(attr) && attr == "true")
                {
                    return null;
                }
                attr = reader.GetAttribute("nil");
                if (!string.IsNullOrEmpty(attr) && attr == "true") { return null; }
            }
            var value = GetString(reader);
            double result;
            if (!double.TryParse(value, System.Globalization.NumberStyles.Float, InvariantCulture, out result))
            {
                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
            }
            return result;
        }

        public static bool GetBool(XmlReader reader)
        {
            var elemName = reader.Name;
            var value = GetString(reader);
            bool result;
            if (!bool.TryParse(value, out result))
            {
                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
            }
            return result;
        }

        public static void PutString(XmlWriter writer, string tag, string value)
        {
            writer.WriteStartElement(tag);
            if (!string.IsNullOrEmpty(value))
            {
                writer.WriteString(value);
            }
            writer.WriteEndElement();
        }

        public static void PutInt(XmlWriter writer, string tag, int value)
        {
            writer.WriteStartElement(tag);
            //if(value != null)
            {
                writer.WriteString(value.ToString(InvariantCulture));
            }
            writer.WriteEndElement();
        }
        ///<summary>
        /// writes a long to xml writer
        /// can throw exceptions
        /// </summary>
        public static void PutInt64(XmlWriter writer, string tag, long value)
        {
            writer.WriteStartElement(tag);
            writer.WriteString(value.ToString(InvariantCulture));
            writer.WriteEndElement();
        }
        public static void PutUInt(XmlWriter writer, string tag, uint value)
        {
            writer.WriteStartElement(tag);
            //if(value != null)
            {
                writer.WriteString(value.ToString(InvariantCulture));
            }
            writer.WriteEndElement();
        }

        public static void PutUInt64(XmlWriter writer, string tag, UInt64 value)
        {
            writer.WriteStartElement(tag);
            writer.WriteString(value.ToString(InvariantCulture));
            writer.WriteEndElement();
        }

        public static void PutDouble(XmlWriter writer, string tag, double value)
        {
            writer.WriteStartElement(tag);
            writer.WriteString(value.ToString("G17", InvariantCulture));
            writer.WriteEndElement();
        }

        public static void PutOptionalDouble(XmlWriter writer, string tag, double? value)
        {
            writer.WriteStartElement(tag);
            if (value == null)
            {
                writer.WriteAttributeString("xsi", "nil", null, "true");
            }
            else
            {
                writer.WriteString(((double)value).ToString("G17", InvariantCulture));
            }
            writer.WriteEndElement();
        }

        public static void PutBool(XmlWriter writer, string tag, bool value)
        {
            writer.WriteStartElement(tag);
            writer.WriteString(value.ToString(InvariantCulture));
            writer.WriteEndElement();
        }
    }
}