//---------------------------------------------------------------------
// <copyright file="EpmContentSerializerBase.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <summary>
// Base Classes used for EntityPropertyMappingAttribute related content 
// serializers
// </summary>
//
// @owner  Microsoft
//---------------------------------------------------------------------
 
namespace System.Data.Services.Common
{
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
#if ASTORIA_CLIENT
    using System.Xml;
#else
    using System.ServiceModel.Syndication;
    using System.Data.Services.Providers;
#endif
 
    /// <summary>
    /// What kind of xml nodes to serialize
    /// </summary>
    internal enum EpmSerializationKind
    {
        /// <summary>
        /// Serialize only attributes
        /// </summary>
        Attributes,
        
        /// <summary>
        /// Serialize only elements
        /// </summary>
        Elements,
        
        /// <summary>
        /// Serialize everything
        /// </summary>
        All
    }
    
    /// <summary>
    /// Base visitor class for performing serialization of content whose location in the syndication
    /// feed is provided through EntityPropertyMappingAttributes
    /// </summary>
    internal abstract class EpmContentSerializerBase
    {
        /// <summary>
        /// Constructor decided whether to use syndication or non-syndication sub-tree for target content mappings
        /// </summary>
        /// <param name="tree">Target tree containing mapping information</param>
        /// <param name="isSyndication">Helps in deciding whether to use syndication sub-tree or non-syndication one</param>
        /// <param name="element">Object to be serialized</param>
        /// <param name="target">SyndicationItem to which content will be added</param>
#if ASTORIA_CLIENT
        protected EpmContentSerializerBase(EpmTargetTree tree, bool isSyndication, object element, XmlWriter target)
#else
        protected EpmContentSerializerBase(EpmTargetTree tree, bool isSyndication, object element, SyndicationItem target)
#endif
        {
            this.Root = isSyndication ? tree.SyndicationRoot : tree.NonSyndicationRoot;
            this.Element = element;
            this.Target = target;
            this.Success = false;
        }
 
        /// <summary>Root of the target tree containing mapped xml elements/attribute</summary>
        protected EpmTargetPathSegment Root
        {
            get;
            private set;
        }
 
        /// <summary>Object whose properties we will read</summary>
        protected object Element
        {
            get;
            private set;
        }
 
        /// <summary>Target SyndicationItem on which we are going to add the serialized content</summary>
#if ASTORIA_CLIENT
        protected XmlWriter Target
#else
        protected SyndicationItem Target
#endif
        {
            get;
            private set;
        }
 
        /// <summary>Indicates the success or failure of serialization</summary>
        protected bool Success
        {
            get;
            private set;
        }
 
#if ASTORIA_CLIENT
        /// <summary>Public interface used by the EpmContentSerializer class</summary>
        internal void Serialize()
#else
        /// <summary>Public interface used by the EpmContentSerializer class</summary>
        /// <param name="provider">Data Service provider used for rights verification.</param>
        internal void Serialize(DataServiceProviderWrapper provider)
#endif
        {
            foreach (EpmTargetPathSegment targetSegment in this.Root.SubSegments)
            {
#if ASTORIA_CLIENT
                this.Serialize(targetSegment, EpmSerializationKind.All);
#else
                this.Serialize(targetSegment, EpmSerializationKind.All, provider);
#endif
            }
            
            this.Success = true;
        }
 
#if ASTORIA_CLIENT
        /// <summary>
        /// Internal interface to be overridden in the subclasses. 
        /// Goes through each subsegments and invokes itself for the children
        /// </summary>
        /// <param name="targetSegment">Current root segment in the target tree</param>
        /// <param name="kind">Which sub segments to serialize</param>
        protected virtual void Serialize(EpmTargetPathSegment targetSegment, EpmSerializationKind kind)
#else
        /// <summary>
        /// Internal interface to be overridden in the subclasses. 
        /// Goes through each subsegments and invokes itself for the children
        /// </summary>
        /// <param name="targetSegment">Current root segment in the target tree</param>
        /// <param name="kind">Which sub segments to serialize</param>
        /// <param name="provider">Data Service provider used for rights verification.</param>
        protected virtual void Serialize(EpmTargetPathSegment targetSegment, EpmSerializationKind kind, DataServiceProviderWrapper provider)
#endif
        {
            IEnumerable<EpmTargetPathSegment> segmentsToSerialize;
            switch (kind)
            {
                case EpmSerializationKind.Attributes:
                    segmentsToSerialize = targetSegment.SubSegments.Where(s => s.IsAttribute == true);
                    break;
                case EpmSerializationKind.Elements:
                    segmentsToSerialize = targetSegment.SubSegments.Where(s => s.IsAttribute == false);
                    break;
                default:
                    Debug.Assert(kind == EpmSerializationKind.All, "Must serialize everything");
                    segmentsToSerialize = targetSegment.SubSegments;
                    break;
            }
 
            foreach (EpmTargetPathSegment segment in segmentsToSerialize)
            {
#if ASTORIA_CLIENT
                this.Serialize(segment, kind);
#else
                this.Serialize(segment, kind, provider);
#endif
            }
        }
    }
}