using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Xml.Linq;

namespace Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStability.Assemblers
{
    /// <summary>
    /// Extnesion helper methods
    /// </summary>
    public static class DtoHelperServices
    {
        /// <summary>
        /// TODO: Solve this hack in a good way!!!
        /// </summary>
        /// <param name="doc"></param>
        /// <returns></returns>
        public static string ToUtf8EncodedStringFix(this XDocument doc)
        {
            string xmlData = doc.ToString();

            // Hack to 
            if (!xmlData.Contains("encoding"))
                xmlData = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + Environment.NewLine + xmlData;

            return xmlData;
        }

        /// <summary>
        /// Assembles a XElement from a domain object
        /// </summary>
        /// <remarks>
        /// Only public properties will be used
        /// </remarks>
        /// <typeparam name="TDomaiObject"></typeparam>
        /// <param name="domainObject"></param>
        /// <param name="elementName"></param>
        /// <returns></returns>
        public static XElement ToXElement<TDomaiObject>(this TDomaiObject domainObject, string elementName)
        {
            return ToXElement(domainObject, elementName, null);
        }

        /// <summary>
        /// Assembles a XElement from a domain object
        /// </summary>
        /// <remarks>
        /// Only public properties will be used
        /// </remarks>
        /// <typeparam name="TDomaiObject"></typeparam>
        /// <param name="domainObject"></param>
        /// <param name="elementName"></param>
        /// <param name="elementNamespace"></param>
        /// <returns></returns>
        public static XElement ToXElement<TDomaiObject>(this TDomaiObject domainObject, string elementName, string elementNamespace)
        {
            if (elementNamespace.HasValidStringValue())
            {
                XNamespace ns = elementNamespace;
                return ToXElement(domainObject, elementName, ns);
            }

            return ToXElement(domainObject, elementName, null);
        }

        /// <summary>
        /// Assembles a XElement from a domain object
        /// </summary>
        /// <remarks>
        /// Only public properties will be used
        /// </remarks>
        /// <typeparam name="TDomaiObject"></typeparam>
        /// <param name="domainObject"></param>
        /// <param name="elementName"></param>
        /// <param name="elementNamespace"></param>
        /// <returns></returns>
        public static XElement ToXElement<TDomaiObject>(this TDomaiObject domainObject, string elementName, XNamespace elementNamespace)
        {
            if (domainObject.Equals(default(TDomaiObject)))
                return null;

            if (!elementName.HasValidStringValue())
                throw new DtoAssemblerException("There is no element name specified");

            if (elementNamespace != null)
            {
                return new XElement(elementNamespace + elementName).Materialize(domainObject);
            }

            return new XElement(elementName).Materialize(domainObject);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TDomainObject"></typeparam>
        /// <param name="assembler"></param>
        /// <param name="domainObj"></param>
        /// <param name="ns"></param>
        /// <returns></returns>
        public static XElement ToDto<TDomainObject>(this TDomainObject domainObj, IDtoAssembler<TDomainObject> assembler, XNamespace elementNamespace)
            where TDomainObject : new()
        {
            XElement element = assembler.CreateDataTransferObject(domainObj);

            if (element == null)
                return null;

            // replace the element name with the given namespace
            var tmp = new XElement(elementNamespace + assembler.ElementName);
            element.Name = tmp.Name;

            return element;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TDomainObject"></typeparam>
        /// <param name="collection"></param>
        /// <param name="elementName"></param>
        /// <returns></returns>
        public static XElement ToDto<TDomainObject>(this IEnumerable<TDomainObject> collection, XName elementName, XName itemElementName)
        {
            return ToDto<TDomainObject>(collection, elementName, itemElementName, null);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TDomainObject"></typeparam>
        /// <param name="collection"></param>
        /// <param name="elementName"></param>
        /// <param name="itemElementName"></param>
        /// <param name="itemAttributeName"></param>
        /// <returns></returns>
        public static XElement ToDto<TDomainObject>(this IEnumerable<TDomainObject> collection, XName elementName, XName itemElementName, XName itemAttributeName)
        {
            if (elementName == null)
                throw new ArgumentNullException("elementName");

            if (itemElementName == null)
                throw new ArgumentNullException("itemElementName");

            var el = new XElement(elementName);
            if (itemAttributeName == null)
            {
                foreach (TDomainObject item in collection)
                    el.Add(new XElement(itemElementName, item));
            }
            else
            {
                foreach (TDomainObject item in collection)
                    el.Add(new XElement(itemElementName, new XAttribute(itemAttributeName, item)));
            }
            return el;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TDomainObject"></typeparam>
        /// <param name="assembler"></param>
        /// <param name="domainObj"></param>
        /// <param name="ns"></param>
        /// <returns></returns>
        public static XElement ToDto<TDomainObject>(this IEnumerable<TDomainObject> domainObjCollection, IDtoCollectionAssembler<TDomainObject> assembler, XNamespace elementNamespace)
            where TDomainObject : new()
        {
            XElement element = assembler.CreateDataTransferObject(domainObjCollection);

            if (element == null)
                return null;

            // replace the element name with the given namespace
            var tmp = new XElement(elementNamespace + assembler.ElementName);
            element.Name = tmp.Name;

            return element;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="domainObjColl"></param>
        /// <param name="assembler"></param>
        /// <returns></returns>
        public static IEnumerable<XElement> ToDtoIterator<T>(this IEnumerable<T> domainObjColl, IDtoAssembler<T, XElement> assembler)
        {
            foreach (T item in domainObjColl)
                yield return assembler.CreateDataTransferObject(item);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dtoObjColl"></param>
        /// <param name="assembler"></param>
        /// <returns></returns>
        public static IEnumerable<T> ToDomainObjectIterator<T>(this IEnumerable<XElement> dtoObjColl, IDtoAssembler<T, XElement> assembler)
        {
            foreach (XElement item in dtoObjColl)
                yield return assembler.CreateDomainObject(item);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dtoObjColl"></param>
        /// <param name="assembler"></param>
        /// <returns></returns>
        public static IEnumerable<T> ToDomainObjectIterator<T>(XElement element, string elementName, string itemElementName, string itemAttributeName)
        {
            IEnumerable<XElement> dto = from x in element.Descendants()
                                        where x.Name.LocalName == itemElementName && x.Parent.Name.LocalName == elementName
                                        select x;

            foreach (XElement item in dto)
                yield return item.AttributeAs<T>(itemAttributeName);
        }

        public static XElement GetFirstOrDefaultElementByLocalName(this XDocument doc, string localName)
        {
            return (from x in doc.Descendants()
                    where x.Name.LocalName == localName
                    select x).FirstOrDefault();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <param name="xsdStream"></param>
        /// <returns></returns>
        public static IEnumerable<DtoPropertyAttriubteMapping> ToPropertyMap<T>(this T type, Stream xsdStream)
        {
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <param name="xsdDocument"></param>
        /// <returns></returns>
        public static IEnumerable<DtoPropertyAttriubteMapping> ToPropertyMap<T>(this T type, XDocument xsdDocument)
        {
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="src"></param>
        /// <returns></returns>
        public static IEnumerable<DtoPropertyAttriubteMapping> ToPropertyMap<T>(this T type)
        {
            foreach (PropertyInfo pInfo in type.GetType().GetProperties())
            {
                object val = null;
                try
                {
                    val = pInfo.GetValue(type, null);
                }
                catch
                {
                    throw new DtoPropertyMapException(string.Format("Error reading property {0} of type {1}", pInfo.Name, pInfo.ReflectedType.Name));
                }

                if (val != null)
                {
                    yield return new DtoPropertyAttriubteMapping()
                                     {
                                         PropertyName = pInfo.Name,
                                         AttributeName = pInfo.Name,
                                         Importance = DtoPropertyImportance.Optional
                                     };
                }
            }
        }

        private static IEnumerable<AttributeInfo> GetAttributes(XDocument doc, string elementName)
        {
            IEnumerable<XElement> element = from x in doc.Descendants()
                                            where x.Attribute("name") != null && x.Attribute("name").Value == elementName
                                            select x;

            if (element.Any())
            {
                if (element.First().Name.LocalName == "complexType")
                {
                    IEnumerable<AttributeInfo> q1 = from x in element.Elements()
                                                    where x.Name.LocalName == "attribute"
                                                    select new AttributeInfo()
                                                               {
                                                                   Name = x.Attribute("name").Value,
                                                                   Use = x.Attribute("use") == null ? "optional" : x.Attribute("use").Value
                                                               };

                    return q1;
                }
                if (element.First().Name.LocalName == "element" &&
                    element.ElementAt(0).HasElements &&
                    element.ElementAt(0).Elements().ElementAt(0).Name.LocalName == "complexType")
                {
                    IEnumerable<AttributeInfo> q2 = from x in element.ElementAt(0).Elements().ElementAt(0).Elements()
                                                    where x.Name.LocalName == "attribute"
                                                    select new AttributeInfo()
                                                               {
                                                                   Name = x.Attribute("name").Value,
                                                                   Use = x.Attribute("use") == null ? "optional" : x.Attribute("use").Value
                                                               };

                    return q2;
                }
            }

            return new List<AttributeInfo>() {};
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="src"></param>
        /// <returns></returns>
        public static IEnumerable<DtoPropertyAttriubteMapping> ToPropertyMap<T>(this T type, string elementName, XDocument doc)
        {
            IEnumerable<AttributeInfo> refTable = GetAttributes(doc, elementName);

            foreach (PropertyInfo pInfo in type.GetType().GetProperties())
            {
                if (refTable.Count() > 0)
                {
                    // does the property exist in the xsd?
                    IEnumerable<AttributeInfo> q = from x in refTable
                                                   where x.Name.Equals(pInfo.Name, StringComparison.InvariantCultureIgnoreCase)
                                                   select x;

                    if (q.Any())
                    {
                        // ok we have a property attribute match we can now 
                        // safely create and return the mapping object
                        AttributeInfo item = q.Single();
                        yield return new DtoPropertyAttriubteMapping()
                                         {
                                             PropertyName = pInfo.Name,
                                             AttributeName = item.Name,
                                             Importance = item.Use == "optional" ?
                                                                                     DtoPropertyImportance.Optional : DtoPropertyImportance.Required
                                         };
                    }
                }
            }
        }

        /// <summary>
        /// Materializes a simple object with the data from a xml file
        /// </summary>
        /// <remarks>
        /// Materialization happens on equal name basis. So the attribute 
        /// local name should be the same as the property name. Also the property type should 
        /// be known by the this method
        /// </remarks>
        /// <typeparam name="T"></typeparam>
        /// <param name="dest"></param>
        /// <param name="src"></param>
        public static T Materialize<T>(this T dest, XElement src)
        {
            return Materialize(dest, src, null);
        }

        /// <summary>
        /// Materializes a domain object with the data from a xml file based on a property map
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dest"></param>
        /// <param name="src"></param>
        /// <param name="propertyMap"></param>
        public static T Materialize<T>(this T dest, XElement src, DtoPropertyAttributeMap propertyMap)
        {
            bool hasPropertyMap = propertyMap != null && propertyMap.Count > 0;

            if (src.HasAttributes)
            {
                XAttribute att = src.FirstAttribute;
                try
                {
                    do
                    {
                        string attName = att.Name.LocalName;
                        object v = att.Value;
                        if (v != null)
                        {
                            PropertyInfo pInfo = null;
                            DtoPropertyAttriubteMapping mapItem = null;
                            if (hasPropertyMap)
                            {
                                mapItem = propertyMap.GetByAttributeName(attName);

                                // Is the property found in the map?
                                if (mapItem != null)
                                    pInfo = typeof (T).GetProperty(mapItem.PropertyName);
                                // else throw ?
                            }
                            else
                                // No property map so try to get property name based on 
                                // the attribute name
                                pInfo = typeof (T).GetProperty(attName);

                            if (pInfo != null)
                            {
                                // does the mapping contains a translation rule for 
                                // the object to parse?
                                if (mapItem != null && mapItem.ToPropertyTranslationRule != null)
                                {
                                    pInfo.SetObjectValue(dest, v, mapItem.ToPropertyTranslationRule);
                                }
                                else
                                {
                                    pInfo.SetObjectValue(dest, v, null);
                                }
                            }
                        }
                    } while ((att = att.NextAttribute) != null);
                }
                catch (DtoAssemblerConversionException ex)
                {
                    throw new DtoAssemblerConversionException(ex.Message);
                }
                catch
                {
                    throw;
                }
            }
            return dest;
        }

        /// <summary>
        /// Extension helper method which materializes a xml element with attributes and its values
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="element"></param>
        /// <param name="src"></param>
        /// <returns></returns>
        public static XElement Materialize<T>(this XElement element, T src)
        {
            var map = new DtoPropertyAttributeMap();

            foreach (PropertyInfo pInfo in src.GetType().GetProperties())
            {
                object val = pInfo.GetValue(src, null);
                if (val != null)
                {
                    map.Add(pInfo.Name, new DtoPropertyAttriubteMapping()
                                            {
                                                PropertyName = pInfo.Name,
                                                AttributeName = pInfo.Name,
                                                Importance = DtoPropertyImportance.Optional
                                            });
                }
            }
            return element.Materialize(src, map);
        }

        /// <summary>
        /// Extension helper method which materializes an xml element with attributes and its values
        /// </summary>
        /// <exception cref="DtoAssemblerRequiredValueException">Throws a required field exception if property is set to required in property map</exception>
        /// <typeparam name="T"></typeparam>
        /// <param name="element"></param>
        /// <param name="src"></param>
        /// <param name="propertyMap"></param>
        /// <returns></returns>
        public static XElement Materialize<T>(this XElement element, T src, DtoPropertyAttributeMap propertyMap)
        {
            PropertyInfo pInfo;
            foreach (var item in propertyMap)
            {
                pInfo = typeof (T).GetProperty(item.Key);
                object val = pInfo.GetValue(src, null);
                if (val != null)
                {
                    string attName = item.Value.AttributeName;
                    element.Add(new XAttribute(attName, val));
                }
                else
                {
                    // Throw required field exception..
                    if (item.Value.Importance == DtoPropertyImportance.Required)
                        throw new MissingRequiredValueException(item.Key);
                }
            }
            return element;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="element"></param>
        /// <param name="elementName"></param>
        /// <param name="elementNamespace"></param>
        /// <returns></returns>
        public static XElement SetNamespace(this XElement element, string elementName, string elementNamespace)
        {
            XNamespace ns = elementNamespace;
            element.Name = new XElement(ns + elementName).Name;
            return element;
        }

        public static XElement SetNamespace(this XElement element, XNamespace elementNamespace)
        {
            element.Name = elementNamespace.GetName(element.Name.LocalName);
            return element;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool HasValidStringValue(this string value)
        {
            return !string.IsNullOrEmpty(value) && value.Trim() != "";
        }

        public static T ToEnum<T>(this object value, IDictionary<string, T> lookup)
        {
            if (value == null)
                throw new ArgumentNullException("value");

            return value.ToEnumType(lookup);
        }

        public static T AttributeAs<T>(this XElement element, XName name)
        {
            var xAttribute = element.Attribute(name);
            if (xAttribute != null)
                return xAttribute.Value.ToType<T>();

            return default(T);
        }

        #region Nested type: AttributeInfo

        private struct AttributeInfo
        {
            public string Name;
            public string Use;
            //public string Type;            
        }

        #endregion
    }
}