//-----------------------------------------------------------------------
// <copyright file="DtoCollectionAssembler.cs" company="Deltares">
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>B. Faassen</author>
// <email>barry.faassen@deltares.nl</email>
// <date>9-2-2009</date>
// <summary>Base class to convert between domain collections and xml (dto) collections</summary>
//-----------------------------------------------------------------------
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using Deltares.Standard.IO.DtoAssembler;

namespace Deltares.Standard
{
    /// <summary>
    /// Base class for a data transfer collection assembler
    /// </summary>
    /// <typeparam name="T">The type of class to be assembled</typeparam>
    public abstract class DtoCollectionAssembler<TDomainObject> : IDtoCollectionAssembler<TDomainObject>
        where TDomainObject : new()
    {
        /// <summary>
        /// Holds a reference to the entity assembler
        /// </summary>
        private DtoAssembler<TDomainObject> entityAssembler;

        public DtoCollectionAssembler(DtoAssembler<TDomainObject> entityAssembler, string elementName)
        {
            this.entityAssembler = entityAssembler;
            this.ElementName = elementName;
        }

        #region IDtoCollectionAssembler<TDomainObject> Members

        /// <summary>
        /// Gets the entity assembler
        /// </summary>
        public IDtoAssembler<TDomainObject> EntityAssembler
        {
            get { return this.entityAssembler; }
        }

        /// <summary>
        /// Gets or sets the xml element name
        /// </summary>
        public string ElementName { get; private set; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="dtoObjColl"></param>
        /// <returns></returns>
        public virtual IEnumerable<TDomainObject> CreateDomainObjectCollection(XElement dtoSequenceElement)
        {
            IEnumerable<XElement> dto = from x in dtoSequenceElement.Descendants()
                                        where x.Name.LocalName == this.EntityAssembler.ElementName && x.Parent.Name.LocalName == this.ElementName
                                        select x;

            return dto.ToDomainObjectIterator(this.entityAssembler);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="domainObjColl"></param>
        /// <returns></returns>
        public virtual XElement CreateDataTransferObject(IEnumerable<TDomainObject> domainObjColl)
        {
            if (!this.ElementName.HasValidStringValue())
                throw new DtoAssemblerException("There is no element name specified");

            if (this.entityAssembler == null)
            {
                // TODO: need to support serialization based on reflection
            }

            // is there a schema attached to the assembler so we can 
            // validate the collection?
            XDocument schema = this.entityAssembler.Schema;
            if (schema != null)
            {
                if (this.entityAssembler == null)
                {
                    // TODO: need to support serialization based on reflection
                }
                else
                {
                    // get the collection rules (min and max requirements) (if any)
                    var collRules = from x in schema.Descendants()
                                    where x.Name.LocalName == "element" && x.Attribute("name").Value == this.entityAssembler.ElementName
                                    select new
                                               {
                                                   MinOccurs = x.AttributeAs<string>("minOccurs") == "unbounded" ? 0 : x.AttributeAs<int>("minOccurs"),
                                                   MaxOccurs = x.AttributeAs<string>("maxOccurs") == "unbounded" ? -1 : x.AttributeAs<int>("maxOccurs")
                                               };

                    if (collRules.Any())
                    {
                        var rules = collRules.Single();
                        // validate the min and max values of the collection according to the xsd
                        int count = domainObjColl.Count();
                        if (domainObjColl == null || (count == 0 && rules.MinOccurs > 0)
                            || (count > 0 & rules.MaxOccurs >= 0 && count > rules.MaxOccurs))
                        {
                            throw new CollectionRequirementsNotSatisfiedException(this.ElementName, this.EntityAssembler.ElementName, domainObjColl);
                        }
                    }
                }
            }
            else if (domainObjColl == null)
            {
                return null; // Use empty sequence instead?
            }

            return new XElement(this.ElementName, domainObjColl.ToDtoIterator(this.entityAssembler).ToArray());
        }

        #endregion

        /// <summary>
        /// Creates a domain object collection from an xml document
        /// </summary>
        /// <param name="dtoObjColl"></param>
        /// <returns></returns>
        public IEnumerable<TDomainObject> CreateDomainObjectCollection(string xmlString)
        {
            XDocument doc = XDocument.Parse(xmlString);

            // assemble the collection
            return this.CreateDomainObjectCollection(doc);
        }

        /// <summary>
        /// Creates a domain object collection from an xml document
        /// </summary>
        /// <param name="dtoObjColl"></param>
        /// <returns></returns>
        public IEnumerable<TDomainObject> CreateDomainObjectCollection(XDocument doc)
        {
            IEnumerable<XElement> dto = from x in doc.Descendants()
                                        where x.Name.LocalName == this.EntityAssembler.ElementName && x.Parent.Name.LocalName == this.ElementName
                                        select x;

            // assemble the collection
            return this.CreateDomainObjectCollection(dto);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="dtoObjColl"></param>
        /// <returns></returns>
        public IEnumerable<TDomainObject> CreateDomainObjectCollection(IEnumerable<XElement> dtoObjColl)
        {
            return dtoObjColl.ToDomainObjectIterator(this.entityAssembler);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="domainObjColl"></param>
        /// <returns></returns>
        public XElement CreateDataTransferObject(IEnumerable<TDomainObject> domainObjColl, XNamespace elementNamespace)
        {
            XElement el = this.CreateDataTransferObject(domainObjColl);
            var nel = new XElement(elementNamespace + this.ElementName);
            el.Name = nel.Name;

            return el;
        }
    }
}