﻿/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Xml;
using System.Xml.Serialization;
using DotCMIS.CMISWebServicesReference;
using DotCMIS.Data;
using DotCMIS.Data.Extensions;
using DotCMIS.Data.Impl;
using DotCMIS.Enums;

namespace DotCMIS.Binding
{
    internal class Converter
    {
        /// <summary>
        /// Converts a repository info.
        /// </summary>
        public static IRepositoryInfo Convert(cmisRepositoryInfoType repositotyInfo)
        {
            if (repositotyInfo == null)
            {
                return null;
            }

            RepositoryInfo result = new RepositoryInfo();
            result.Id = repositotyInfo.repositoryId;
            result.Name = repositotyInfo.repositoryName;
            result.Description = repositotyInfo.repositoryDescription;
            result.VendorName = repositotyInfo.vendorName;
            result.ProductName = repositotyInfo.productName;
            result.ProductVersion = repositotyInfo.productVersion;
            result.RootFolderId = repositotyInfo.rootFolderId;
            result.Capabilities = Convert(repositotyInfo.capabilities);
            result.AclCapabilities = Convert(repositotyInfo.aclCapability);
            result.LatestChangeLogToken = repositotyInfo.latestChangeLogToken;
            result.CmisVersionSupported = repositotyInfo.cmisVersionSupported;
            result.ThinClientUri = repositotyInfo.thinClientURI;
            result.ChangesIncomplete = (repositotyInfo.changesIncompleteSpecified ? (bool?)repositotyInfo.changesIncomplete : null);
            result.ChangesOnType = new List<BaseTypeId?>();
            if (repositotyInfo.changesOnType != null)
            {
                foreach (enumBaseObjectTypeIds baseType in repositotyInfo.changesOnType)
                {
                    result.ChangesOnType.Add((BaseTypeId?)CmisValue.SerializerToCmisEnum(baseType));
                }
            }
            result.PrincipalIdAnonymous = repositotyInfo.principalAnonymous;
            result.PrincipalIdAnyone = repositotyInfo.principalAnyone;

            ConvertExtension(repositotyInfo, result);

            return result;
        }

        /// <summary>
        /// Converts repository capabilities.
        /// </summary>
        public static IRepositoryCapabilities Convert(cmisRepositoryCapabilitiesType capabilities)
        {
            if (capabilities == null)
            {
                return null;
            }

            RepositoryCapabilities result = new RepositoryCapabilities();
            result.ContentStreamUpdatesCapability = (CapabilityContentStreamUpdates)CmisValue.SerializerToCmisEnum(capabilities.capabilityContentStreamUpdatability);
            result.ChangesCapability = (CapabilityChanges)CmisValue.SerializerToCmisEnum(capabilities.capabilityChanges);
            result.RenditionsCapability = (CapabilityRenditions)CmisValue.SerializerToCmisEnum(capabilities.capabilityRenditions);
            result.IsGetDescendantsSupported = capabilities.capabilityGetDescendants;
            result.IsGetFolderTreeSupported = capabilities.capabilityGetFolderTree;
            result.IsMultifilingSupported = capabilities.capabilityMultifiling;
            result.IsUnfilingSupported = capabilities.capabilityUnfiling;
            result.IsVersionSpecificFilingSupported = capabilities.capabilityVersionSpecificFiling;
            result.IsPwcSearchableSupported = capabilities.capabilityPWCSearchable;
            result.IsPwcUpdatableSupported = capabilities.capabilityPWCUpdatable;
            result.IsAllVersionsSearchableSupported = capabilities.capabilityAllVersionsSearchable;
            result.QueryCapability = (CapabilityQuery)CmisValue.SerializerToCmisEnum(capabilities.capabilityQuery);
            result.JoinCapability = (CapabilityJoin)CmisValue.SerializerToCmisEnum(capabilities.capabilityJoin);
            result.AclCapability = (CapabilityAcl)CmisValue.SerializerToCmisEnum(capabilities.capabilityACL);

            ConvertExtension(capabilities, result);

            return result;
        }

        /// <summary>
        /// Converts ACL capabilities.
        /// </summary>
        public static IAclCapabilities Convert(cmisACLCapabilityType capabilities)
        {
            if (capabilities == null)
            {
                return null;
            }

            AclCapabilities result = new AclCapabilities();
            result.SupportedPermissions = (SupportedPermissions)CmisValue.SerializerToCmisEnum(capabilities.supportedPermissions);
            result.AclPropagation = (AclPropagation)CmisValue.SerializerToCmisEnum(capabilities.propagation);
            result.Permissions = new List<IPermissionDefinition>();
            if (capabilities.permissions != null)
            {
                foreach (cmisPermissionDefinition permission in capabilities.permissions)
                {
                    PermissionDefinition permDef = new PermissionDefinition();
                    permDef.Id = permission.permission;
                    permDef.Description = permission.description;
                    result.Permissions.Add(permDef);

                    ConvertExtension(permission, permDef);
                }
            }
            result.PermissionMapping = new Dictionary<string, IPermissionMapping>();
            if (capabilities.mapping != null)
            {
                foreach (cmisPermissionMapping mapping in capabilities.mapping)
                {
                    PermissionMapping permMap = new PermissionMapping();
                    permMap.Key = GetXmlEnumAttributeValue(mapping.key);
                    permMap.Permissions = new List<string>();
                    if (mapping.permission != null)
                    {
                        foreach (string s in mapping.permission)
                        {
                            permMap.Permissions.Add(s);
                        }
                    }

                    result.PermissionMapping[permMap.Key] = permMap;

                    ConvertExtension(mapping, permMap);
                }
            }

            ConvertExtension(capabilities, result);

            return result;
        }

        public static ITypeDefinition Convert(cmisTypeDefinitionType typeDef)
        {
            if (typeDef == null)
            {
                return null;
            }

            AbstractTypeDefinition result = null;
            if (typeDef is cmisTypeDocumentDefinitionType)
            {
                DocumentTypeDefinition docType = new DocumentTypeDefinition();
                cmisTypeDocumentDefinitionType docTypeDef = (cmisTypeDocumentDefinitionType)typeDef;

                docType.IsVersionable = docTypeDef.versionable;
                docType.ContentStreamAllowed = (ContentStreamAllowed)CmisValue.SerializerToCmisEnum(docTypeDef.contentStreamAllowed);

                result = docType;
            }
            else if (typeDef is cmisTypeFolderDefinitionType)
            {
                result = new FolderTypeDefinition();
            }
            else if (typeDef is cmisTypePolicyDefinitionType)
            {
                result = new PolicyTypeDefinition();
            }
            else if (typeDef is cmisTypeRelationshipDefinitionType)
            {
                RelationshipTypeDefinition relType = new RelationshipTypeDefinition();
                cmisTypeRelationshipDefinitionType relTypeDef = (cmisTypeRelationshipDefinitionType)typeDef;

                if (relTypeDef.allowedSourceTypes != null)
                {
                    relType.AllowedSourceTypeIds = new List<string>();
                    foreach (string id in relTypeDef.allowedSourceTypes)
                    {
                        relType.AllowedSourceTypeIds.Add(id);
                    }
                }

                if (relTypeDef.allowedTargetTypes != null)
                {
                    relType.AllowedTargetTypeIds = new List<string>();
                    foreach (string id in relTypeDef.allowedTargetTypes)
                    {
                        relType.AllowedTargetTypeIds.Add(id);
                    }
                }

                result = relType;
            }

            result.Id = typeDef.id;
            result.LocalName = typeDef.localName;
            result.LocalNamespace = typeDef.localNamespace;
            result.DisplayName = typeDef.displayName;
            result.QueryName = typeDef.queryName;
            result.Description = typeDef.description;
            result.BaseTypeId = (BaseTypeId)CmisValue.SerializerToCmisEnum(typeDef.baseId);
            result.ParentTypeId = typeDef.parentId;
            result.IsCreatable = typeDef.creatable;
            result.IsFileable = typeDef.fileable;
            result.IsQueryable = typeDef.queryable;
            result.IsFulltextIndexed = typeDef.fulltextIndexed;
            result.IsIncludedInSupertypeQuery = typeDef.includedInSupertypeQuery;
            result.IsControllablePolicy = typeDef.controllablePolicy;
            result.IsControllableAcl = typeDef.controllableACL;

            if (typeDef.Items != null)
            {
                foreach (cmisPropertyDefinitionType propertyDefinition in typeDef.Items)
                {
                    result.AddPropertyDefinition(Convert(propertyDefinition));
                }
            }

            ConvertExtension(typeDef, result);

            return result;
        }

        public static IPropertyDefinition Convert(cmisPropertyDefinitionType propDef)
        {
            if (propDef == null) { return null; }

            PropertyDefinition result = null;
            if (propDef is cmisPropertyBooleanDefinitionType)
            {
                PropertyBooleanDefinition pd = new PropertyBooleanDefinition();
                cmisPropertyBooleanDefinitionType cpd = (cmisPropertyBooleanDefinitionType)propDef;

                if (cpd.defaultValue != null && cpd.defaultValue.value != null)
                {
                    pd.DefaultValue = new List<bool>();
                    foreach (bool value in cpd.defaultValue.value) { pd.DefaultValue.Add(value); }
                }
                if (cpd.choice != null)
                {
                    pd.Choices = new List<IChoice<bool>>();
                    foreach (cmisChoiceBoolean c in cpd.choice) { pd.Choices.Add(ConvertChoice(c)); }
                }

                result = pd;
            }
            else if (propDef is cmisPropertyDateTimeDefinitionType)
            {
                PropertyDateTimeDefinition pd = new PropertyDateTimeDefinition();
                cmisPropertyDateTimeDefinitionType cpd = (cmisPropertyDateTimeDefinitionType)propDef;

                if (cpd.defaultValue != null && cpd.defaultValue.value != null)
                {
                    pd.DefaultValue = new List<DateTime>();
                    foreach (DateTime value in cpd.defaultValue.value) { pd.DefaultValue.Add(value); }
                }
                if (cpd.choice != null)
                {
                    pd.Choices = new List<IChoice<DateTime>>();
                    foreach (cmisChoiceDateTime c in cpd.choice) { pd.Choices.Add(ConvertChoice(c)); }
                }

                if (cpd.resolutionSpecified)
                {
                    pd.DateTimeResolution = (DateTimeResolution)CmisValue.SerializerToCmisEnum(cpd.resolution);
                }

                result = pd;
            }
            else if (propDef is cmisPropertyDecimalDefinitionType)
            {
                PropertyDecimalDefinition pd = new PropertyDecimalDefinition();
                cmisPropertyDecimalDefinitionType cpd = (cmisPropertyDecimalDefinitionType)propDef;

                if (cpd.defaultValue != null && cpd.defaultValue.value != null)
                {
                    pd.DefaultValue = new List<decimal>();
                    foreach (decimal value in cpd.defaultValue.value) { pd.DefaultValue.Add(value); }
                }
                if (cpd.choice != null)
                {
                    pd.Choices = new List<IChoice<decimal>>();
                    foreach (cmisChoiceDecimal c in cpd.choice) { pd.Choices.Add(ConvertChoice(c)); }
                }

                if (cpd.maxValueSpecified)
                {
                    pd.MaxValue = cpd.maxValue;
                }
                if (cpd.minValueSpecified)
                {
                    pd.MinValue = cpd.minValue;
                }
                if (cpd.precisionSpecified)
                {
                    pd.Precision = (DecimalPrecision)CmisValue.SerializerToCmisEnum(cpd.precision);
                }

                result = pd;
            }
            else if (propDef is cmisPropertyHtmlDefinitionType)
            {
                PropertyHtmlDefinition pd = new PropertyHtmlDefinition();
                cmisPropertyHtmlDefinitionType cpd = (cmisPropertyHtmlDefinitionType)propDef;

                if (cpd.defaultValue != null && cpd.defaultValue.value != null)
                {
                    pd.DefaultValue = new List<string>();
                    foreach (string value in cpd.defaultValue.value) { pd.DefaultValue.Add(value); }
                }
                if (cpd.choice != null)
                {
                    pd.Choices = new List<IChoice<string>>();
                    foreach (cmisChoiceHtml c in cpd.choice) { pd.Choices.Add(ConvertChoice(c)); }
                }

                result = pd;
            }
            else if (propDef is cmisPropertyIdDefinitionType)
            {
                PropertyIdDefinition pd = new PropertyIdDefinition();
                cmisPropertyIdDefinitionType cpd = (cmisPropertyIdDefinitionType)propDef;

                if (cpd.defaultValue != null && cpd.defaultValue.value != null)
                {
                    pd.DefaultValue = new List<string>();
                    foreach (string value in cpd.defaultValue.value) { pd.DefaultValue.Add(value); }
                }
                if (cpd.choice != null)
                {
                    pd.Choices = new List<IChoice<string>>();
                    foreach (cmisChoiceId c in cpd.choice) { pd.Choices.Add(ConvertChoice(c)); }
                }

                result = pd;
            }
            else if (propDef is cmisPropertyIntegerDefinitionType)
            {
                PropertyIntegerDefinition pd = new PropertyIntegerDefinition();
                cmisPropertyIntegerDefinitionType cpd = (cmisPropertyIntegerDefinitionType)propDef;

                if (cpd.defaultValue != null && cpd.defaultValue.value != null)
                {
                    pd.DefaultValue = new List<long>();
                    foreach (string value in cpd.defaultValue.value) { pd.DefaultValue.Add(Int64.Parse(value)); }
                }
                if (cpd.choice != null)
                {
                    pd.Choices = new List<IChoice<long>>();
                    foreach (cmisChoiceInteger c in cpd.choice) { pd.Choices.Add(ConvertChoice(c)); }
                }

                if (cpd.maxValue != null)
                {
                    pd.MaxValue = Int64.Parse(cpd.maxValue);
                }
                if (cpd.minValue != null)
                {
                    pd.MinValue = Int64.Parse(cpd.minValue);
                }

                result = pd;
            }
            else if (propDef is cmisPropertyStringDefinitionType)
            {
                PropertyStringDefinition pd = new PropertyStringDefinition();
                cmisPropertyStringDefinitionType cpd = (cmisPropertyStringDefinitionType)propDef;

                if (cpd.defaultValue != null && cpd.defaultValue.value != null)
                {
                    pd.DefaultValue = new List<string>();
                    foreach (string value in cpd.defaultValue.value) { pd.DefaultValue.Add(value); }
                }
                if (cpd.choice != null)
                {
                    pd.Choices = new List<IChoice<string>>();
                    foreach (cmisChoiceString c in cpd.choice) { pd.Choices.Add(ConvertChoice(c)); }
                }

                if (cpd.maxLength != null)
                {
                    pd.MaxLength = Int64.Parse(cpd.maxLength);
                }

                result = pd;
            }
            else if (propDef is cmisPropertyUriDefinitionType)
            {
                PropertyUriDefinition pd = new PropertyUriDefinition();
                cmisPropertyUriDefinitionType cpd = (cmisPropertyUriDefinitionType)propDef;

                if (cpd.defaultValue != null && cpd.defaultValue.value != null)
                {
                    pd.DefaultValue = new List<string>();
                    foreach (string value in cpd.defaultValue.value) { pd.DefaultValue.Add(value); }
                }
                if (cpd.choice != null)
                {
                    pd.Choices = new List<IChoice<string>>();
                    foreach (cmisChoiceUri c in cpd.choice) { pd.Choices.Add(ConvertChoice(c)); }
                }

                result = pd;
            }

            result.Id = propDef.id;
            result.LocalName = propDef.localName;
            result.LocalNamespace = propDef.localNamespace;
            result.DisplayName = propDef.displayName;
            result.QueryName = propDef.queryName;
            result.Description = propDef.description;
            result.PropertyType = (PropertyType)CmisValue.SerializerToCmisEnum(propDef.propertyType);
            result.Cardinality = (Cardinality)CmisValue.SerializerToCmisEnum(propDef.cardinality);
            result.Updatability = (Updatability)CmisValue.SerializerToCmisEnum(propDef.updatability);
            result.IsInherited = (propDef.inheritedSpecified ? (bool?)propDef.inherited : null);
            result.IsRequired = propDef.required;
            result.IsQueryable = propDef.queryable;
            result.IsOrderable = propDef.orderable;
            result.IsOpenChoice = (propDef.openChoiceSpecified ? (bool?)propDef.openChoice : null);

            ConvertExtension(propDef, result);

            return result;
        }

        private static IChoice<bool> ConvertChoice(cmisChoiceBoolean choice)
        {
            if (choice == null) { return null; }

            Choice<bool> result = new Choice<bool>();
            result.DisplayName = choice.displayName;
            if (choice.value != null)
            {
                result.Value = new List<bool>();
                foreach (bool v in choice.value) { result.Value.Add(v); }
            }
            if (choice.choice != null)
            {
                result.Choices = new List<IChoice<bool>>();
                foreach (cmisChoiceBoolean sc in choice.choice) { result.Choices.Add(ConvertChoice(sc)); }
            }

            return result;
        }

        private static IChoice<DateTime> ConvertChoice(cmisChoiceDateTime choice)
        {
            if (choice == null) { return null; }

            Choice<DateTime> result = new Choice<DateTime>();
            result.DisplayName = choice.displayName;
            if (choice.value != null)
            {
                result.Value = new List<DateTime>();
                foreach (DateTime v in choice.value) { result.Value.Add(v); }
            }
            if (choice.choice != null)
            {
                result.Choices = new List<IChoice<DateTime>>();
                foreach (cmisChoiceDateTime sc in choice.choice) { result.Choices.Add(ConvertChoice(sc)); }
            }

            return result;
        }

        private static IChoice<decimal> ConvertChoice(cmisChoiceDecimal choice)
        {
            if (choice == null) { return null; }

            Choice<decimal> result = new Choice<decimal>();
            result.DisplayName = choice.displayName;
            if (choice.value != null)
            {
                result.Value = new List<decimal>();
                foreach (decimal v in choice.value) { result.Value.Add(v); }
            }
            if (choice.choice != null)
            {
                result.Choices = new List<IChoice<decimal>>();
                foreach (cmisChoiceDecimal sc in choice.choice) { result.Choices.Add(ConvertChoice(sc)); }
            }

            return result;
        }

        private static IChoice<string> ConvertChoice(cmisChoiceHtml choice)
        {
            if (choice == null) { return null; }

            Choice<string> result = new Choice<string>();
            result.DisplayName = choice.displayName;
            if (choice.value != null)
            {
                result.Value = new List<string>();
                foreach (string v in choice.value) { result.Value.Add(v); }
            }
            if (choice.choice != null)
            {
                result.Choices = new List<IChoice<string>>();
                foreach (cmisChoiceHtml sc in choice.choice) { result.Choices.Add(ConvertChoice(sc)); }
            }

            return result;
        }

        private static IChoice<string> ConvertChoice(cmisChoiceId choice)
        {
            if (choice == null) { return null; }

            Choice<string> result = new Choice<string>();
            result.DisplayName = choice.displayName;
            if (choice.value != null)
            {
                result.Value = new List<string>();
                foreach (string v in choice.value) { result.Value.Add(v); }
            }
            if (choice.choice != null)
            {
                result.Choices = new List<IChoice<string>>();
                foreach (cmisChoiceId sc in choice.choice) { result.Choices.Add(ConvertChoice(sc)); }
            }

            return result;
        }

        private static IChoice<long> ConvertChoice(cmisChoiceInteger choice)
        {
            if (choice == null) { return null; }

            Choice<long> result = new Choice<long>();
            result.DisplayName = choice.displayName;
            if (choice.value != null)
            {
                result.Value = new List<long>();
                foreach (string v in choice.value) { result.Value.Add(Int64.Parse(v)); }
            }
            if (choice.choice != null)
            {
                result.Choices = new List<IChoice<long>>();
                foreach (cmisChoiceInteger sc in choice.choice) { result.Choices.Add(ConvertChoice(sc)); }
            }

            return result;
        }

        private static IChoice<string> ConvertChoice(cmisChoiceString choice)
        {
            if (choice == null) { return null; }

            Choice<string> result = new Choice<string>();
            result.DisplayName = choice.displayName;
            if (choice.value != null)
            {
                result.Value = new List<string>();
                foreach (string v in choice.value) { result.Value.Add(v); }
            }
            if (choice.choice != null)
            {
                result.Choices = new List<IChoice<string>>();
                foreach (cmisChoiceString sc in choice.choice) { result.Choices.Add(ConvertChoice(sc)); }
            }

            return result;
        }

        private static IChoice<string> ConvertChoice(cmisChoiceUri choice)
        {
            if (choice == null) { return null; }

            Choice<string> result = new Choice<string>();
            result.DisplayName = choice.displayName;
            if (choice.value != null)
            {
                result.Value = new List<string>();
                foreach (string v in choice.value) { result.Value.Add(v); }
            }
            if (choice.choice != null)
            {
                result.Choices = new List<IChoice<string>>();
                foreach (cmisChoiceUri sc in choice.choice) { result.Choices.Add(ConvertChoice(sc)); }
            }

            return result;
        }


        /// <summary>
        /// Converts a type defintion list.
        /// </summary> 
        public static ITypeDefinitionList Convert(cmisTypeDefinitionListType typeDefList)
        {
            if (typeDefList == null) { return null; }

            TypeDefinitionList result = new TypeDefinitionList();

            if (typeDefList.types != null)
            {
                result.List = new List<ITypeDefinition>();
                foreach (cmisTypeDefinitionType type in typeDefList.types)
                {
                    result.List.Add(Convert(type));
                }
            }

            result.HasMoreItems = typeDefList.hasMoreItems;
            result.NumItems = typeDefList.numItems == null ? null : (long?)Int64.Parse(typeDefList.numItems);

            ConvertExtension(typeDefList, result);

            return result;
        }

        /// <summary>
        /// Converts a type defintion container.
        /// </summary> 
        public static ITypeDefinitionContainer Convert(cmisTypeContainer typeDefCont)
        {
            if (typeDefCont == null) { return null; }

            TypeDefinitionContainer result = new TypeDefinitionContainer();
            result.TypeDefinition = Convert(typeDefCont.type);
            if (typeDefCont.children != null)
            {
                result.Children = new List<ITypeDefinitionContainer>();
                foreach (cmisTypeContainer container in typeDefCont.children)
                {
                    result.Children.Add(Convert(container));
                }
            }

            ConvertExtension(typeDefCont, result);

            return result;
        }

        public static IObjectData Convert(cmisObjectType cmisObject)
        {
            if (cmisObject == null) { return null; }

            ObjectData result = new ObjectData();
            result.Properties = Convert(cmisObject.properties);
            result.AllowableActions = Convert(cmisObject.allowableActions);
            if (cmisObject.relationship != null)
            {
                result.Relationships = new List<IObjectData>();
                foreach (cmisObjectType co in cmisObject.relationship)
                {
                    result.Relationships.Add(Convert(co));
                }
            }
            result.ChangeEventInfo = Convert(cmisObject.changeEventInfo);
            result.IsExactAcl = cmisObject.exactACLSpecified ? (bool?)cmisObject.exactACL : null;
            result.Acl = Convert(cmisObject.acl, result.IsExactAcl);
            result.PolicyIds = Convert(cmisObject.policyIds);
            if (cmisObject.rendition != null)
            {
                result.Renditions = new List<IRenditionData>();
                foreach (cmisRenditionType rendition in cmisObject.rendition)
                {
                    result.Renditions.Add(Convert(rendition));
                }
            }

            ConvertExtension(cmisObject, result);

            return result;
        }

        public static IProperties Convert(cmisPropertiesType properties)
        {
            if (properties == null) { return null; }

            Properties result = new Properties();
            if (properties.Items != null)
            {
                foreach (cmisProperty property in properties.Items)
                {
                    result.AddProperty(Convert(property));
                }
            }

            ConvertExtension(properties, result);

            return result;
        }
        public static IPropertyData Convert(cmisProperty property)
        {
            if (property == null) { return null; }

            PropertyData result = null;
            if (property is cmisPropertyString)
            {
                result = new PropertyData(PropertyType.String);
                if (((cmisPropertyString)property).value != null)
                {
                    foreach (string value in ((cmisPropertyString)property).value)
                    {
                        result.AddValue(value);
                    }
                }
            }
            else if (property is cmisPropertyId)
            {
                result = new PropertyData(PropertyType.Id);
                if (((cmisPropertyId)property).value != null)
                {
                    foreach (string value in ((cmisPropertyId)property).value)
                    {
                        result.AddValue(value);
                    }
                }
            }
            else if (property is cmisPropertyInteger)
            {
                result = new PropertyData(PropertyType.Integer);
                if (((cmisPropertyInteger)property).value != null)
                {
                    foreach (string value in ((cmisPropertyInteger)property).value)
                    {
                        result.AddValue(Int64.Parse(value));
                    }
                }
            }
            else if (property is cmisPropertyBoolean)
            {
                result = new PropertyData(PropertyType.Boolean);
                if (((cmisPropertyBoolean)property).value != null)
                {
                    foreach (bool value in ((cmisPropertyBoolean)property).value)
                    {
                        result.AddValue(value);
                    }
                }
            }
            else if (property is cmisPropertyDateTime)
            {
                result = new PropertyData(PropertyType.DateTime);
                if (((cmisPropertyDateTime)property).value != null)
                {
                    foreach (DateTime value in ((cmisPropertyDateTime)property).value)
                    {
                        result.AddValue(value);
                    }
                }
            }
            else if (property is cmisPropertyDecimal)
            {
                result = new PropertyData(PropertyType.Decimal);
                if (((cmisPropertyDecimal)property).value != null)
                {
                    foreach (decimal value in ((cmisPropertyDecimal)property).value)
                    {
                        result.AddValue(value);
                    }
                }
            }
            else if (property is cmisPropertyHtml)
            {
                result = new PropertyData(PropertyType.Html);
                if (((cmisPropertyHtml)property).value != null)
                {
                    foreach (string value in ((cmisPropertyHtml)property).value)
                    {
                        result.AddValue(value);
                    }
                }
            }
            else if (property is cmisPropertyUri)
            {
                result = new PropertyData(PropertyType.Uri);
                if (((cmisPropertyUri)property).value != null)
                {
                    foreach (string value in ((cmisPropertyUri)property).value)
                    {
                        result.AddValue(value);
                    }
                }
            }

            result.Id = property.propertyDefinitionId;
            result.LocalName = property.localName;
            result.DisplayName = property.displayName;
            result.QueryName = property.queryName;

            ConvertExtension(property, result);

            return result;
        }


        public static cmisPropertiesType Convert(IProperties properties)
        {
            if (properties == null) { return null; }

            cmisPropertiesType result = new cmisPropertiesType();
            if (properties.PropertyList != null)
            {
                result.Items = new cmisProperty[properties.PropertyList.Count];
                for (int i = 0; i < properties.PropertyList.Count; i++)
                {
                    result.Items[i] = Convert(properties.PropertyList[i]);
                }
            }

            ConvertExtension(properties, result);

            return result;
        }

        public static cmisProperty Convert(IPropertyData property)
        {
            if (property == null) { return null; }

            cmisProperty result = null;

            switch (property.PropertyType)
            {
                case PropertyType.String:
                    result = new cmisPropertyString();
                    if (property.Values != null)
                    {
                        ((cmisPropertyString)result).value = new string[property.Values.Count];
                        for (int i = 0; i < property.Values.Count; i++)
                        {
                            ((cmisPropertyString)result).value[i] = property.Values[i] as string;
                        }
                    }
                    break;
                case PropertyType.Id:
                    result = new cmisPropertyId();
                    if (property.Values != null)
                    {
                        ((cmisPropertyId)result).value = new string[property.Values.Count];
                        for (int i = 0; i < property.Values.Count; i++)
                        {
                            ((cmisPropertyId)result).value[i] = property.Values[i] as string;
                        }
                    }
                    break;
                case PropertyType.Integer:
                    result = new cmisPropertyInteger();
                    if (property.Values != null)
                    {
                        ((cmisPropertyInteger)result).value = new string[property.Values.Count];
                        for (int i = 0; i < property.Values.Count; i++)
                        {
                            long? value = property.Values[i] as long?;
                            if (value.HasValue)
                            {
                                ((cmisPropertyInteger)result).value[i] = value.ToString();
                            }
                        }
                    }
                    break;
                case PropertyType.Boolean:
                    result = new cmisPropertyBoolean();
                    if (property.Values != null)
                    {
                        ((cmisPropertyBoolean)result).value = new bool[property.Values.Count];
                        for (int i = 0; i < property.Values.Count; i++)
                        {
                            bool? value = property.Values[i] as bool?;
                            if (value.HasValue)
                            {
                                ((cmisPropertyBoolean)result).value[i] = value.Value;
                            }
                        }
                    }
                    break;
                case PropertyType.DateTime:
                    result = new cmisPropertyDateTime();
                    if (property.Values != null)
                    {
                        ((cmisPropertyDateTime)result).value = new DateTime[property.Values.Count];
                        for (int i = 0; i < property.Values.Count; i++)
                        {
                            DateTime? value = property.Values[i] as DateTime?;
                            if (value.HasValue)
                            {
                                ((cmisPropertyDateTime)result).value[i] = value.Value;
                            }
                        }
                    }
                    break;
                case PropertyType.Decimal:
                    result = new cmisPropertyDecimal();
                    if (property.Values != null)
                    {
                        ((cmisPropertyDecimal)result).value = new decimal[property.Values.Count];
                        for (int i = 0; i < property.Values.Count; i++)
                        {
                            decimal? value = property.Values[i] as decimal?;
                            if (value.HasValue)
                            {
                                ((cmisPropertyDecimal)result).value[i] = value.Value;
                            }
                        }
                    }
                    break;
                case PropertyType.Html:
                    result = new cmisPropertyHtml();
                    if (property.Values != null)
                    {
                        ((cmisPropertyHtml)result).value = new string[property.Values.Count];
                        for (int i = 0; i < property.Values.Count; i++)
                        {
                            ((cmisPropertyHtml)result).value[i] = property.Values[i] as string;
                        }
                    }
                    break;
                case PropertyType.Uri:
                    result = new cmisPropertyUri();
                    if (property.Values != null)
                    {
                        ((cmisPropertyUri)result).value = new string[property.Values.Count];
                        for (int i = 0; i < property.Values.Count; i++)
                        {
                            ((cmisPropertyUri)result).value[i] = property.Values[i] as string;
                        }
                    }
                    break;
            }

            result.propertyDefinitionId = property.Id;
            result.localName = property.LocalName;
            result.displayName = property.DisplayName;
            result.queryName = property.QueryName;

            ConvertExtension(property, result);

            return result;
        }

        public static IAllowableActions Convert(cmisAllowableActionsType allowableActions)
        {
            if (allowableActions == null) { return null; }

            AllowableActions result = new AllowableActions();
            result.Actions = new HashSet<string>();

            if (allowableActions.canDeleteObject && allowableActions.canDeleteObjectSpecified)
            { result.Actions.Add(Actions.CanDeleteObject); }

            if (allowableActions.canUpdateProperties && allowableActions.canUpdatePropertiesSpecified)
            { result.Actions.Add(Actions.CanUpdateProperties); }

            if (allowableActions.canGetFolderTree && allowableActions.canGetFolderTreeSpecified)
            { result.Actions.Add(Actions.CanGetFolderTree); }

            if (allowableActions.canGetProperties && allowableActions.canGetPropertiesSpecified)
            { result.Actions.Add(Actions.CanGetProperties); }

            if (allowableActions.canGetObjectRelationships && allowableActions.canGetObjectRelationshipsSpecified)
            { result.Actions.Add(Actions.CanGetObjectRelationships); }

            if (allowableActions.canGetObjectParents && allowableActions.canGetObjectParentsSpecified)
            { result.Actions.Add(Actions.CanGetObjectParents); }

            if (allowableActions.canGetFolderParent && allowableActions.canGetFolderParentSpecified)
            { result.Actions.Add(Actions.CanGetFolderParent); }

            if (allowableActions.canGetDescendants && allowableActions.canGetDescendantsSpecified)
            { result.Actions.Add(Actions.CanGetDescendants); }

            if (allowableActions.canMoveObject && allowableActions.canMoveObjectSpecified)
            { result.Actions.Add(Actions.CanMoveObject); }

            if (allowableActions.canDeleteContentStream && allowableActions.canDeleteContentStreamSpecified)
            { result.Actions.Add(Actions.CanDeleteContentStream); }

            if (allowableActions.canCheckOut && allowableActions.canCheckOutSpecified)
            { result.Actions.Add(Actions.CanCheckOut); }

            if (allowableActions.canCancelCheckOut && allowableActions.canCancelCheckOutSpecified)
            { result.Actions.Add(Actions.CanCancelCheckOut); }

            if (allowableActions.canCheckIn && allowableActions.canCheckInSpecified)
            { result.Actions.Add(Actions.CanCheckIn); }

            if (allowableActions.canSetContentStream && allowableActions.canSetContentStreamSpecified)
            { result.Actions.Add(Actions.CanSetContentStream); }

            if (allowableActions.canGetAllVersions && allowableActions.canGetAllVersionsSpecified)
            { result.Actions.Add(Actions.CanGetAllVersions); }

            if (allowableActions.canAddObjectToFolder && allowableActions.canAddObjectToFolderSpecified)
            { result.Actions.Add(Actions.CanAddObjectToFolder); }

            if (allowableActions.canRemoveObjectFromFolder && allowableActions.canRemoveObjectFromFolderSpecified)
            { result.Actions.Add(Actions.CanRemoveObjectFromFolder); }

            if (allowableActions.canGetContentStream && allowableActions.canGetContentStreamSpecified)
            { result.Actions.Add(Actions.CanGetContentStream); }

            if (allowableActions.canApplyPolicy && allowableActions.canApplyPolicySpecified)
            { result.Actions.Add(Actions.CanApplyPolicy); }

            if (allowableActions.canGetAppliedPolicies && allowableActions.canGetAppliedPoliciesSpecified)
            { result.Actions.Add(Actions.CanGetAppliedPolicies); }

            if (allowableActions.canRemovePolicy && allowableActions.canRemovePolicySpecified)
            { result.Actions.Add(Actions.CanRemovePolicy); }

            if (allowableActions.canGetChildren && allowableActions.canGetChildrenSpecified)
            { result.Actions.Add(Actions.CanGetChildren); }

            if (allowableActions.canCreateDocument && allowableActions.canCreateDocumentSpecified)
            { result.Actions.Add(Actions.CanCreateDocument); }

            if (allowableActions.canCreateFolder && allowableActions.canCreateFolderSpecified)
            { result.Actions.Add(Actions.CanCreateFolder); }

            if (allowableActions.canCreateRelationship && allowableActions.canCreateRelationshipSpecified)
            { result.Actions.Add(Actions.CanCreateRelationship); }

            if (allowableActions.canDeleteTree && allowableActions.canDeleteTreeSpecified)
            { result.Actions.Add(Actions.CanDeleteTree); }

            if (allowableActions.canGetRenditions && allowableActions.canGetRenditionsSpecified)
            { result.Actions.Add(Actions.CanGetRenditions); }

            if (allowableActions.canGetACL && allowableActions.canGetACLSpecified)
            { result.Actions.Add(Actions.CanGetAcl); }

            if (allowableActions.canApplyACL && allowableActions.canApplyACLSpecified)
            { result.Actions.Add(Actions.CanApplyAcl); }

            ConvertExtension(allowableActions, result);

            return result;
        }

        public static IAcl Convert(cmisAccessControlListType acl, bool? isExact)
        {
            if (acl == null) { return null; }

            Acl result = new Acl();
            if (acl.permission != null)
            {
                result.Aces = new List<IAce>();
                foreach (cmisAccessControlEntryType ace in acl.permission)
                {
                    result.Aces.Add(Convert(ace));
                }
            }
            result.IsExact = isExact;

            ConvertExtension(acl, result);

            return result;
        }


        public static IAcl Convert(cmisACLType acl)
        {
            if (acl == null) { return null; }

            Acl result = new Acl();
            if (acl.ACL != null && acl.ACL.permission != null)
            {
                result.Aces = new List<IAce>();
                foreach (cmisAccessControlEntryType ace in acl.ACL.permission)
                {
                    result.Aces.Add(Convert(ace));
                }
            }
            result.IsExact = (acl.exactSpecified ? (bool?)acl.exactSpecified : null);

            ConvertExtension(acl, result);

            return result;
        }


        public static IAce Convert(cmisAccessControlEntryType ace)
        {
            if (ace == null) { return null; }

            Ace result = new Ace();
            if (ace.principal != null)
            {
                Principal principal = new Principal();
                principal.Id = ace.principal.principalId;
                result.Principal = principal;

                ConvertExtension(ace.principal, principal);
            }
            if (ace.permission != null)
            {
                result.Permissions = new List<string>();
                foreach (string permission in ace.permission)
                {
                    result.Permissions.Add(permission);
                }
            }
            result.IsDirect = ace.direct;

            ConvertExtension(ace, result);

            return result;
        }

        public static cmisAccessControlListType Convert(IAcl acl)
        {
            if (acl == null) { return null; }

            cmisAccessControlListType result = new cmisAccessControlListType();
            if (acl.Aces != null)
            {
                result.permission = new cmisAccessControlEntryType[acl.Aces.Count];
                for (int i = 0; i < acl.Aces.Count; i++)
                {
                    result.permission[i] = Convert(acl.Aces[i]);
                }
            }

            ConvertExtension(acl, result);

            return result;
        }

        public static cmisAccessControlEntryType Convert(IAce ace)
        {
            if (ace == null) { return null; }

            cmisAccessControlEntryType result = new cmisAccessControlEntryType();
            if (ace.Principal != null)
            {
                result.principal = new cmisAccessControlPrincipalType();
                result.principal.principalId = ace.Principal.Id;

                ConvertExtension(ace.Principal, result.principal);
            }
            if (ace.Permissions != null)
            {
                result.permission = new string[ace.Permissions.Count];
                for (int i = 0; i < ace.Permissions.Count; i++)
                {
                    result.permission[i] = ace.Permissions[i];
                }
            }
            result.direct = ace.IsDirect;

            ConvertExtension(ace, result);

            return result;
        }


        public static IPolicyIdList Convert(cmisListOfIdsType policyIdList)
        {
            if (policyIdList == null) { return null; }

            PolicyIdList result = new PolicyIdList();
            if (policyIdList.id != null)
            {
                result.PolicyIds = new List<string>();
                foreach (string id in policyIdList.id)
                {
                    result.PolicyIds.Add(id);
                }
            }

            ConvertExtension(policyIdList, result);

            return result;
        }

        public static cmisListOfIdsType ConvertPolicies(IList<string> policyIds)
        {
            if (policyIds == null) { return null; }

            cmisListOfIdsType result = new cmisListOfIdsType();
            result.id = new string[policyIds.Count];
            for (int i = 0; i < policyIds.Count; i++)
            {
                result.id[i] = policyIds[i];
            }

            return result;
        }


        public static IRenditionData Convert(cmisRenditionType rendition)
        {
            if (rendition == null) { return null; }

            RenditionData result = new RenditionData();
            result.StreamId = rendition.streamId;
            result.MimeType = rendition.mimetype;
            result.Length = Int64.Parse(rendition.length);
            result.Kind = rendition.kind;
            result.Title = rendition.title;
            result.Height = Int64.Parse(rendition.height);
            result.Width = Int64.Parse(rendition.width);
            result.RenditionDocumentId = rendition.renditionDocumentId;

            ConvertExtension(rendition, result);

            return result;
        }

        public static IChangeEventInfo Convert(cmisChangeEventType changeEvent)
        {
            if (changeEvent == null) { return null; }

            ChangeEventInfo result = new ChangeEventInfo();
            result.ChangeType = (ChangeType)CmisValue.SerializerToCmisEnum(changeEvent.changeType);
            result.ChangeTime = changeEvent.changeTime;

            ConvertExtension(changeEvent, result);

            return result;
        }

        public static IObjectInFolderList Convert(cmisObjectInFolderListType list)
        {
            if (list == null) { return null; }

            ObjectInFolderList result = new ObjectInFolderList();
            if (list.objects != null)
            {
                result.Objects = new List<IObjectInFolderData>();
                foreach (cmisObjectInFolderType fo in list.objects)
                {
                    result.Objects.Add(Convert(fo));
                }
            }
            result.HasMoreItems = list.hasMoreItems;
            result.NumItems = list.numItems == null ? null : (long?)Int64.Parse(list.numItems);

            ConvertExtension(list, result);

            return result;
        }


        public static IObjectInFolderData Convert(cmisObjectInFolderType objectInFolder)
        {
            if (objectInFolder == null) { return null; }

            ObjectInFolderData result = new ObjectInFolderData();
            result.Object = Convert(objectInFolder.@object);
            result.PathSegment = objectInFolder.pathSegment;

            ConvertExtension(objectInFolder, result);

            return result;
        }

        public static IObjectInFolderContainer Convert(cmisObjectInFolderContainerType container)
        {
            if (container == null) { return null; }

            ObjectInFolderContainer result = new ObjectInFolderContainer();
            result.Object = Convert(container.objectInFolder);
            if (container.children != null)
            {
                result.Children = new List<IObjectInFolderContainer>();
                foreach (cmisObjectInFolderContainerType child in container.children)
                {
                    result.Children.Add(Convert(child));
                }
            }

            ConvertExtension(container, result);

            return result;
        }

        public static IObjectParentData Convert(cmisObjectParentsType parent)
        {
            if (parent == null) { return null; }

            ObjectParentData result = new ObjectParentData();
            result.Object = Convert(parent.@object);
            result.RelativePathSegment = parent.relativePathSegment;

            ConvertExtension(parent, result);

            return result;
        }

        public static IObjectList Convert(cmisObjectListType list)
        {
            if (list == null) { return null; }

            ObjectList result = new ObjectList();
            if (list.objects != null)
            {
                result.Objects = new List<IObjectData>();
                foreach (cmisObjectType obj in list.objects)
                {
                    result.Objects.Add(Convert(obj));
                }
            }

            result.HasMoreItems = list.hasMoreItems;
            result.NumItems = list.numItems == null ? null : (long?)Int64.Parse(list.numItems);

            ConvertExtension(list, result);

            return result;
        }

        public static IContentStream Convert(cmisContentStreamType contentStream)
        {
            if (contentStream == null) { return null; }

            ContentStream result = new ContentStream();
            if (contentStream.length != null)
            {
                result.Length = Int64.Parse(contentStream.length);
            }
            result.MimeType = contentStream.mimeType;
            result.FileName = contentStream.filename;
            // Todo: enable real streaming
            result.Stream = new MemoryStream(contentStream.stream);

            ConvertExtension(contentStream, result);

            return result;
        }

        public static cmisContentStreamType Convert(IContentStream contentStream)
        {
            if (contentStream == null) { return null; }

            cmisContentStreamType result = new cmisContentStreamType();
            result.length = contentStream.Length.ToString();
            result.mimeType = contentStream.MimeType;
            result.filename = contentStream.FileName;
            if (contentStream.Stream != null)
            {
                if (contentStream.Stream is MemoryStream)
                {
                    result.stream = ((MemoryStream)contentStream.Stream).ToArray();
                }
                else
                {
                    MemoryStream memStream = new MemoryStream();
                    byte[] buffer = new byte[4096];
                    int bytes;
                    while ((bytes = contentStream.Stream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        memStream.Write(buffer, 0, bytes);
                    }
                    result.stream = memStream.ToArray();
                }
            }

            return result;
        }

        public static IFailedToDeleteData Convert(deleteTreeResponseFailedToDelete failedToDelete)
        {
            if (failedToDelete == null) { return null; }

            FailedToDeleteData result = new FailedToDeleteData();
            if (failedToDelete.objectIds != null)
            {
                result.Ids = new List<string>();
                foreach (string id in failedToDelete.objectIds)
                {
                    result.Ids.Add(id);
                }
            }

            ConvertExtension(failedToDelete, result);

            return result;
        }

        public static T[] ConvertList<T>(IList<T> list)
        {
            if (list == null) { return null; }

            T[] result = new T[list.Count];
            for (int i = 0; i < list.Count; i++)
            {
                result[i] = list[i];
            }

            return result;
        }

        /// <summary>
        /// Converts an extension.
        /// </summary> 
        public static void ConvertExtension(object source, IExtensionsData target)
        {
            if (source == null || target == null) { return; }

            Type type = source.GetType();
            PropertyInfo propInfo = type.GetProperty("Any");
            if (propInfo == null)
            {
                return;
            }

            XmlElement[] elements = (XmlElement[])propInfo.GetValue(source, null);
            if (elements == null)
            {
                return;
            }

            target.Extensions = new List<ICmisExtensionElement>();
            foreach (XmlElement xmlElement in elements)
            {
                ICmisExtensionElement element = CreateCmisExtensionElement(xmlElement);
                if (element != null)
                {
                    target.Extensions.Add(element);
                }
            }
        }

        private static ICmisExtensionElement CreateCmisExtensionElement(XmlNode xmlElement)
        {
            CmisExtensionElement result = new CmisExtensionElement();
            result.Name = xmlElement.Name;
            result.Namespace = xmlElement.NamespaceURI;

            if (xmlElement.Attributes != null && xmlElement.Attributes.Count > 0)
            {
                result.Attributes = new Dictionary<string, string>();
                foreach (XmlAttribute attr in xmlElement.Attributes)
                {
                    result.Attributes[attr.Name] = attr.Value;
                }
            }

            if (xmlElement.HasChildNodes)
            {
                result.Children = new List<ICmisExtensionElement>();
                foreach (XmlNode node in xmlElement.ChildNodes)
                {
                    ICmisExtensionElement element = CreateCmisExtensionElement(node);
                    if (element != null)
                    {
                        result.Children.Add(element);
                    }
                }
            }
            else
            {
                result.Value = xmlElement.Value;
            }

            return result;
        }

        /// <summary>
        /// Converts an extension.
        /// </summary>
        public static cmisExtensionType ConvertExtension(IExtensionsData extension)
        {
            if (extension == null || extension.Extensions == null) { return null; }

            XmlDocument doc = new XmlDocument();

            List<XmlElement> elements = new List<XmlElement>();
            foreach (ICmisExtensionElement element in extension.Extensions)
            {
                if (element == null) { continue; }
                elements.Add(CreateXmlElement(doc, element));
            }

            cmisExtensionType result = new cmisExtensionType();
            result.Any = elements.ToArray();

            return result;
        }

        public static void ConvertExtension(IExtensionsData source, object target)
        {
            if (source == null || source.Extensions == null || target == null)
            {
                return;
            }

            Type type = target.GetType();
            PropertyInfo propInfo = type.GetProperty("Any");
            if (propInfo == null)
            {
                return;
            }

            XmlDocument doc = new XmlDocument();

            List<XmlElement> elements = new List<XmlElement>();
            foreach (ICmisExtensionElement element in source.Extensions)
            {
                if (element == null) { continue; }
                elements.Add(CreateXmlElement(doc, element));
            }

            propInfo.SetValue(target, elements.ToArray(), null);
        }

        private static XmlElement CreateXmlElement(XmlDocument doc, ICmisExtensionElement element)
        {
            if (element == null)
            {
                return null;
            }

            XmlElement result = doc.CreateElement(element.Name, element.Namespace);

            if (element.Attributes != null)
            {
                foreach (string key in element.Attributes.Keys)
                {
                    XmlAttribute attr = doc.CreateAttribute(key);
                    attr.Value = element.Attributes[key];
                    result.Attributes.Append(attr);
                }
            }

            if (element.Value != null)
            {
                result.Value = element.Value;
            }
            else if (element.Children != null)
            {
                List<XmlElement> children = new List<XmlElement>();
                foreach (ICmisExtensionElement child in element.Children)
                {
                    XmlElement xml = CreateXmlElement(doc, child);
                    if (xml != null)
                    {
                        result.AppendChild(xml);
                    }
                }
            }

            return result;
        }

        public static string GetXmlEnumAttributeValue(Enum xsdEnum)
        {
            FieldInfo fieldInfo = xsdEnum.GetType().GetField(xsdEnum.ToString());
            XmlEnumAttribute[] xmlAttr = fieldInfo.GetCustomAttributes(typeof(XmlEnumAttribute), false) as XmlEnumAttribute[];

            if (xmlAttr.Length == 0)
            {
                return null;
            }

            return xmlAttr[0].Name;
        }
    }
}