//---------------------------------------------------------------------
// <copyright file="PropertyEmitter.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner       Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------

using System.CodeDom;
using System.Collections.Generic;
using System.Data.Entity.Design;
using System.Data.Entity.Design.Common;
using System.Data.Entity.Design.SsdlGenerator;
using System.Data.Metadata.Edm;
using System.Data.Objects.ELinq;
using System.Diagnostics;
using System.Globalization;

namespace System.Data.EntityModel.Emitters
{
    internal sealed class PropertyEmitter : PropertyEmitterBase
    {
        private CodeFieldReferenceExpression _fieldRef = null;
        private CodeFieldReferenceExpression _complexPropertyInitializedFieldRef = null;

        // statics
        private const string NestedStoreObjectCollection = "InlineObjectCollection";
        private const string DetachFromParentMethodName = "DetachFromParent";

        #region Public Methods

        public PropertyEmitter(ClientApiGenerator generator, EdmProperty property, bool declaringTypeUsesStandardBaseType)
            : base(generator, property, declaringTypeUsesStandardBaseType)
        {
        }

        /// <summary>
        /// Emit the declaration of the property for the class.
        /// </summary>
        /// <returns>The Property declaration pieces of the CodeDom.</returns>
        public CodeMemberProperty EmitPropertyDeclaration(CodeTypeReference propertyReturnType)
        {
            MemberAttributes scope = AccessibilityFromGettersAndSetters(Item);
            CodeMemberProperty memberProperty = EmitPropertyDeclaration(scope, propertyReturnType, IsVirtualProperty, HidesBaseClassProperty);

            memberProperty.HasSet = true;
            memberProperty.HasGet = true;

            return memberProperty;
        }

        /// <summary>
        /// Main method for Emitting property code.
        /// </summary>
        /// <param name="typeDecl">The CodeDom representation of the type that the property is being added to.</param>
        protected override void EmitProperty(CodeTypeDeclaration typeDecl)
        {
            CodeTypeReference typeRef = PropertyType;

            // raise the PropertyGenerated event
            //
            PropertyGeneratedEventArgs eventArgs = new PropertyGeneratedEventArgs(Item, FieldName, typeRef);
            this.Generator.RaisePropertyGeneratedEvent(eventArgs);

            // the event subscriber cannot change the return type of the property
            //
            DisallowReturnTypeChange(typeRef, eventArgs.ReturnType);

            CodeMemberProperty memberProperty = EmitPropertyDeclaration(eventArgs.ReturnType);
            if (memberProperty == null)
            {
                return;
            }

            EmitCustomAttributes(memberProperty, eventArgs.AdditionalAttributes);

            EmitPropertyGetter(memberProperty, eventArgs.AdditionalGetStatements);
            EmitPropertySetter(memberProperty, eventArgs.AdditionalSetStatements);
            typeDecl.Members.Add(memberProperty);

            EmitField(typeDecl, eventArgs.ReturnType);

            EmitPropertyOnChangePartialMethods(typeDecl, eventArgs.ReturnType);
        }

        /// <summary>
        /// Emit these methods as "abstract" and fix them up later to be "partial".
        /// CodeDOM does not support partial methods
        /// </summary>
        /// <param name="typeDecl"></param>
        private void EmitPropertyOnChangePartialMethods(CodeTypeDeclaration typeDecl, CodeTypeReference returnType)
        {
            CodeMemberMethod onChangingDomMethod = new CodeMemberMethod();
            Generator.AttributeEmitter.EmitGeneratedCodeAttribute(onChangingDomMethod);
            onChangingDomMethod.Name = OnChangingPartialMethodName(PropertyName);
            onChangingDomMethod.ReturnType = new CodeTypeReference(typeof(void));
            onChangingDomMethod.Attributes = MemberAttributes.Abstract | MemberAttributes.Public;
            onChangingDomMethod.Parameters.Add(new CodeParameterDeclarationExpression(returnType, "value"));
            typeDecl.Members.Add(onChangingDomMethod);

            CodeMemberMethod onChangedDomMethod = new CodeMemberMethod();
            Generator.AttributeEmitter.EmitGeneratedCodeAttribute(onChangedDomMethod);
            onChangedDomMethod.Name = OnChangedPartialMethodName(PropertyName);
            onChangedDomMethod.ReturnType = new CodeTypeReference(typeof(void));
            onChangedDomMethod.Attributes = MemberAttributes.Abstract | MemberAttributes.Public;
            typeDecl.Members.Add(onChangedDomMethod);

            Generator.FixUps.Add(new FixUp(PropertyClassName + "." + OnChangingPartialMethodName(PropertyName), FixUpType.MarkAbstractMethodAsPartial));
            Generator.FixUps.Add(new FixUp(PropertyClassName + "." + OnChangedPartialMethodName(PropertyName), FixUpType.MarkAbstractMethodAsPartial));
        }

        private void EmitField(CodeTypeDeclaration typeDecl, CodeTypeReference fieldType)
        {
            CodeMemberField memberField = new CodeMemberField(fieldType, FieldName);
            Generator.AttributeEmitter.EmitGeneratedCodeAttribute(memberField);

            memberField.Attributes = MemberAttributes.Private;
            if (HasDefault(Item))
            {
                memberField.InitExpression = GetDefaultValueExpression(Item);
            }

            typeDecl.Members.Add(memberField);

            if (MetadataUtil.IsComplexType(Item.TypeUsage.EdmType))
            {
                CodeMemberField complexInitField = new CodeMemberField(TypeReference.ForType(typeof(bool)), ComplexPropertyInitializedFieldName);
                Generator.AttributeEmitter.EmitGeneratedCodeAttribute(complexInitField);
                complexInitField.Attributes = MemberAttributes.Private;
                typeDecl.Members.Add(complexInitField);
            }
        }

        /// <summary>
        /// Get a reference to the base class DataObject
        /// </summary>
        public static CodeTypeReferenceExpression CreateEdmStructuralObjectRef(TypeReference typeReference)
        {
            return new CodeTypeReferenceExpression(typeReference.ForType(typeof(System.Data.Objects.DataClasses.StructuralObject)));
        }

        #endregion

        #region Public Properties

        public CodeTypeReference PropertyType
        {
            get
            {
                CodeTypeReference typeRef = GetType(Item, false);
                return typeRef;
            }
        }

        public new EdmProperty Item
        {
            get
            {
                return base.Item as EdmProperty;
            }
        }

        #endregion

        #region Internal Methods

        /// <summary>
        /// Name of the associated Entity property for Ref(T) properties
        /// </summary>
        public string EntityPropertyName
        {
            get
            {
                return Item.Name;
            }
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// 
        /// </summary>
        /// <param name="memberProperty"></param>
        /// <param name="additionalAttributes">Additional attributes to emit</param>
        private void EmitCustomAttributes(CodeMemberProperty memberProperty,
                                          List<CodeAttributeDeclaration> additionalAttributes)
        {
            Generator.AttributeEmitter.EmitPropertyAttributes(this, memberProperty, additionalAttributes);
        }

        private void EmitPropertyGetter(CodeMemberProperty memberProperty, List<CodeStatement> additionalGetStatements)
        {
            CodeStatementCollection statements = memberProperty.GetStatements;

            // we need to insert user-specified code before other/existing code, including
            // the return statement
            if (additionalGetStatements != null && additionalGetStatements.Count > 0)
            {
                try
                {
                    CodeStatementCollection getStatements = new CodeStatementCollection();
                    getStatements.AddRange(additionalGetStatements.ToArray());
                    if (statements != null && statements.Count > 0)
                    {
                        getStatements.AddRange(statements);
                    }
                    statements.Clear();
                    statements.AddRange(getStatements);
                }
                catch (ArgumentNullException e)
                {
                    Generator.AddError(Strings.InvalidGetStatementSuppliedForProperty(Item.Name),
                                       ModelBuilderErrorCode.InvalidGetStatementSuppliedForProperty,
                                       EdmSchemaErrorSeverity.Error,
                                       e);
                }
            }

            MemberAttributes access = memberProperty.Attributes & MemberAttributes.AccessMask;

            AddGetterSetterFixUp(Generator.FixUps, PropertyFQName, GetGetterAccessibility(Item), access, true);

            EmitPropertyGetterBody(statements);
        }

        private void EmitPropertyGetterBody(CodeStatementCollection statements)
        {
            // If the SchemaElement.Type isn't a ComplexType it better be PrimitiveType.
            if (MetadataUtil.IsComplexType(Item.TypeUsage.EdmType))
            {
                //Since Complex Collections are not supported by
                //the stack, we don't need to do anything special 
                //like doing an Attach or Detatch like the way we do for complex types.
                if (GetCollectionKind(Item.TypeUsage) == CollectionKind.None)
                {
                    // _field = GetValidValue( _field, FieldPropertyInfo, _fieldInitialized);
                    statements.Add(
                        new CodeAssignStatement(FieldRef,
                            new CodeMethodInvokeExpression(
                                    ThisRef,
                                    Utils.GetValidValueMethodName,
                                    new CodeDirectionExpression(FieldDirection.In, FieldRef),
                                    new CodePrimitiveExpression(PropertyName),
                                    new CodePrimitiveExpression(Item.Nullable),
                                    ComplexPropertyInitializedFieldRef)));

                    // this._complexPropertyInitialized = true;
                    statements.Add(
                        new CodeAssignStatement(
                            ComplexPropertyInitializedFieldRef,
                            new CodePrimitiveExpression(true)));
                }
                // return _field;
                statements.Add(new CodeMethodReturnStatement(FieldRef));
            }
            else
            {
                PrimitiveType primitiveType = Item.TypeUsage.EdmType as PrimitiveType;
                if (primitiveType != null && primitiveType.ClrEquivalentType == typeof(byte[]))
                {
                    // return GetValidValue(_field);
                    statements.Add(
                        new CodeMethodReturnStatement(
                            new CodeMethodInvokeExpression(
                                CreateEdmStructuralObjectRef(TypeReference),
                                Utils.GetValidValueMethodName,
                                this.FieldRef)));
                }
                else
                {
                    // for everything else just return the field.
                    statements.Add(new CodeMethodReturnStatement(FieldRef));
                }
            }
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="memberProperty"></param>
        /// <param name="additionalSetStatements">Additional statements to emit</param>
        private void EmitPropertySetter(CodeMemberProperty memberProperty, List<CodeStatement> additionalSetStatements)
        {
            CodeStatementCollection statements = memberProperty.SetStatements;

            MemberAttributes access = memberProperty.Attributes & MemberAttributes.AccessMask;

            AddGetterSetterFixUp(Generator.FixUps, PropertyFQName, GetSetterAccessibility(Item), access, false);

            EmitPropertySetterBody(statements, additionalSetStatements);
        }

        /// <summary>
        /// This is a control function to delegate the creation of the 
        /// setter statments to the correct code path
        /// </summary>
        /// <param name="statements">The collection that the setter statements should be added to.</param>
        /// <param name="additionalSetStatements">Additional statements to emit</param>
        private void EmitPropertySetterBody(CodeStatementCollection statements, List<CodeStatement> additionalSetStatements)
        {
            // Invoke the partial method "On[PropertyName]Changing();
            statements.Add(
                new CodeMethodInvokeExpression(
                    ThisRef,
                    OnChangingPartialMethodName(PropertyName), new CodePropertySetValueReferenceExpression()));

            // ReportPropertyChanging( _piFieldName );
            statements.Add(
                new CodeMethodInvokeExpression(
                    ThisRef,
                    Utils.ReportPropertyChangingMethodName,
                    new CodePrimitiveExpression(PropertyName)));

            // insert additional statements following the PropertyChanging event
            if (additionalSetStatements != null && additionalSetStatements.Count > 0)
            {
                try
                {
                    statements.AddRange(additionalSetStatements.ToArray());
                }
                catch (ArgumentNullException e)
                {
                    Generator.AddError(Strings.InvalidSetStatementSuppliedForProperty(Item.Name),
                                       ModelBuilderErrorCode.InvalidSetStatementSuppliedForProperty,
                                       EdmSchemaErrorSeverity.Error,
                                       e);
                }
            }

            if (MetadataUtil.IsPrimitiveType(Item.TypeUsage.EdmType))
            {
                EmitScalarTypePropertySetStatements(statements, CollectionKind.None);
            }
            else if (MetadataUtil.IsComplexType(Item.TypeUsage.EdmType))
            {
                // ComplexTypes have a completely different set pattern:
                EmitComplexTypePropertySetStatements(statements, CollectionKind.None);
            }
            else if (MetadataUtil.IsCollectionType(Item.TypeUsage.EdmType))
            {
                if (MetadataUtil.IsComplexType(((CollectionType)Item.TypeUsage.EdmType).TypeUsage.EdmType))
                {
                    EmitComplexTypePropertySetStatements(statements, GetCollectionKind(Item.TypeUsage));
                }
                else
                {
                    Debug.Assert(MetadataUtil.IsPrimitiveType(((CollectionType)Item.TypeUsage.EdmType).TypeUsage.EdmType),
                        "Collections should be of primitive types or complex types");
                    EmitScalarTypePropertySetStatements(statements, GetCollectionKind(Item.TypeUsage));
                }

            }
            else if (MetadataUtil.IsEnumerationType(Item.TypeUsage.EdmType))
            {
                // this.fieldName = value;
                statements.Add(
                    new CodeAssignStatement(
                            FieldRef,
                            new CodePropertySetValueReferenceExpression()));

            }

            // ReportPropertyChanged( _piFieldName );
            statements.Add(
                new CodeMethodInvokeExpression(
                    ThisRef,
                    Utils.ReportPropertyChangedMethodName,
                    new CodePrimitiveExpression(PropertyName)));

            // Invoke the partial method "On[PropertyName]Changed();
            statements.Add(
                new CodeMethodInvokeExpression(
                    ThisRef,
                    OnChangedPartialMethodName(PropertyName)));
        }

        /// <summary>
        /// Do the fixups to allow get and set statements in properties
        /// to have different accessibility than the property itself.
        /// </summary>
        /// <param name="accessibility">The accessibility for the getter or setter</param>
        /// <param name="propertyAccessibility">The property's accessibility</param>
        /// <param name="isGetter">True if this is a getter, false if a setter</param>
        internal static void AddGetterSetterFixUp(FixUpCollection fixups, string propertyFqName, MemberAttributes accessibility, MemberAttributes propertyAccessibility, bool isGetter)
        {
            Debug.Assert(GetAccessibilityRank(accessibility) >= 0, "bad accessibility");

            // Private
            if (accessibility == MemberAttributes.Private && propertyAccessibility != MemberAttributes.Private)
            {
                if (isGetter)
                {
                    fixups.Add(new FixUp(propertyFqName, FixUpType.MarkPropertyGetAsPrivate));
                }
                else
                {
                    fixups.Add(new FixUp(propertyFqName, FixUpType.MarkPropertySetAsPrivate));
                }
            }

            // Internal
            if (accessibility == MemberAttributes.Assembly && propertyAccessibility != MemberAttributes.Assembly)
            {
                if (isGetter)
                {
                    fixups.Add(new FixUp(propertyFqName, FixUpType.MarkPropertyGetAsInternal));
                }
                else
                {
                    fixups.Add(new FixUp(propertyFqName, FixUpType.MarkPropertySetAsInternal));
                }
            }

            // Public
            if (accessibility == MemberAttributes.Public && propertyAccessibility != MemberAttributes.Public)
            {
                if (isGetter)
                {
                    fixups.Add(new FixUp(propertyFqName, FixUpType.MarkPropertyGetAsPublic));
                }
                else
                {
                    fixups.Add(new FixUp(propertyFqName, FixUpType.MarkPropertySetAsPublic));
                }
            }

            // Protected
            if (accessibility == MemberAttributes.Family && propertyAccessibility != MemberAttributes.Family)
            {
                if (isGetter)
                {
                    fixups.Add(new FixUp(propertyFqName, FixUpType.MarkPropertyGetAsProtected));
                }
                else
                {
                    fixups.Add(new FixUp(propertyFqName, FixUpType.MarkPropertySetAsProtected));
                }
            }

        }

        /// <summary>
        /// Emit the set statements for a property that is a scalar type
        /// </summary>
        /// <param name="statements">The statement collection to add the set statements to.</param>
        private void EmitScalarTypePropertySetStatements(CodeStatementCollection statements,
            CollectionKind collectionKind)
        {
            Debug.Assert(statements != null, "statments can't be null");
            Debug.Assert(((MetadataUtil.IsPrimitiveType(Item.TypeUsage.EdmType)) || (MetadataUtil.IsCollectionType(Item.TypeUsage.EdmType)))
                , "Must be a primitive type or collection type property");

            CodePropertySetValueReferenceExpression valueRef = new CodePropertySetValueReferenceExpression();
            //Since collections are not supported by
            //the stack, we don't need to do anything special 
            //like doing an Attach or Detatch like the way we do for complex types.
            if (collectionKind == CollectionKind.None)
            {

                PrimitiveType primitiveType = (PrimitiveType)Item.TypeUsage.EdmType;

                // basic pattern
                // this.fieldName = SetValidValue( value );
                //
                List<CodeExpression> parameters = new List<CodeExpression>();
                parameters.Add(valueRef);


                // pattern for non Nullable<T> types (string, byte[])
                //
                // this.fieldName = SetValidVaue( value, nullability );

                if (primitiveType.ClrEquivalentType.IsClass)
                {
                    // ref types have an extra boolean parameter to tell if the property is allowed to 
                    // be null or not
                    parameters.Add(new CodePrimitiveExpression(Item.Nullable));
                }

                // now create and add the built statement
                statements.Add(
                    new CodeAssignStatement(
                            FieldRef,
                            new CodeMethodInvokeExpression(
                                CreateEdmStructuralObjectRef(TypeReference),
                                Utils.SetValidValueMethodName,
                                parameters.ToArray())));
            }
            else
            {
                // this.fieldName = value;
                statements.Add(
                    new CodeAssignStatement(
                        FieldRef, valueRef));

            }
        }

        private CodeExpression GetEnumValue<T>(T value)
        {
            Type type = typeof(T);
            return new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(TypeReference.ForType(type)), Enum.GetName(type, value));
        }

        /// <summary>
        /// Emit the property set statments to properly set a ComplexType.
        /// </summary>
        /// <param name="statements">The collection of statements that the set statements should be added to.</param>
        private void EmitComplexTypePropertySetStatements(CodeStatementCollection statements, CollectionKind collectionKind)
        {
            CodePropertySetValueReferenceExpression valueRef = new CodePropertySetValueReferenceExpression();
            //Since collections are not supported by
            //the stack, we don't need to do anything special 
            //like doing an Attach or Detatch like the way we do for complex types.
            if (collectionKind == CollectionKind.None)
            {

                // this.fieldName = SetValidValue( this.fieldName, value, _pifieldName);
                statements.Add(
                    new CodeAssignStatement(
                        FieldRef,
                        new CodeMethodInvokeExpression(
                                ThisRef,
                                Utils.SetValidValueMethodName,
                                FieldRef,
                                valueRef,
                                new CodePrimitiveExpression(PropertyName))));

                // this._complexPropertyInitialized = true;
                statements.Add(
                    new CodeAssignStatement(
                        ComplexPropertyInitializedFieldRef,
                        new CodePrimitiveExpression(true)));
            }
            else
            {
                // this.fieldName = value;
                statements.Add(
                    new CodeAssignStatement(
                        FieldRef, valueRef));

            }

        }

        /// <summary>
        /// See if a property names will hide a base class member name
        /// </summary>
        private bool HidesBaseClassProperty
        {
            get
            {
                StructuralType parentBaseClass = Item.DeclaringType.BaseType as StructuralType;
                if (parentBaseClass != null && parentBaseClass.Members.Contains(PropertyName))
                    return true;

                return false;
            }
        }

        private CodeTypeReference GetType(EdmProperty property, bool getElementType)
        {
            PropertyTypeReferences types = default(PropertyTypeReferences);
            EdmType propertyType = property.TypeUsage.EdmType;

            // Initialize types
            if (MetadataUtil.IsPrimitiveType(propertyType))
            {
                types = new PropertyTypeReferences(TypeReference, (PrimitiveType)propertyType);
            }
            else if (MetadataUtil.IsComplexType(propertyType))
            {
                types = new PropertyTypeReferences(TypeReference, (ComplexType)propertyType, Generator);
            }
            else if (Helper.IsCollectionType(propertyType))
            {
                TypeUsage typeUsage = ((CollectionType)propertyType).TypeUsage;
                if (MetadataUtil.IsPrimitiveType(typeUsage.EdmType))
                {
                    types = new PropertyTypeReferences(TypeReference, (PrimitiveType)typeUsage.EdmType, GetCollectionKind(property.TypeUsage));
                }
                else
                {
                    Debug.Assert(MetadataUtil.IsComplexType(typeUsage.EdmType));
                    types = new PropertyTypeReferences(TypeReference, (ComplexType)typeUsage.EdmType, GetCollectionKind(property.TypeUsage), Generator);
                }
            }
            else
            {
                // shouldn't be able to get here....
                Debug.Fail("Unexpected Property.Type type: " + propertyType.GetType());
            }

            // Set types, or retrieve existing types if they have been set in the interim
            // Don't cache Collection types since CollectionKind is really a facet and
            //it is not part of the key we are using for the dictionary used to cache.
            if (!Helper.IsCollectionType(propertyType))
            {
                Debug.Assert(types.NonNullable != null && types.Nullable != null, "did you forget to set the types variable?");
            }

            if (property.Nullable)
            {
                return types.Nullable;
            }
            else
            {
                return types.NonNullable;
            }
        }


        private static CollectionKind GetCollectionKind(TypeUsage usage)
        {
            Facet collectionFacet;
            if (usage.Facets.TryGetValue(EdmConstants.CollectionKind, false, out collectionFacet))
            {
                return (CollectionKind)collectionFacet.Value;
            }

            return CollectionKind.None;
        }

        private string OnChangingPartialMethodName(string propertyName) { return "On" + propertyName + "Changing"; }
        private string OnChangedPartialMethodName(string propertyName) { return "On" + propertyName + "Changed"; }

        #endregion

        #region Private Properties

        private CodeFieldReferenceExpression FieldRef
        {
            get
            {
                if (_fieldRef == null)
                    _fieldRef = new CodeFieldReferenceExpression(ThisRef, FieldName);

                return _fieldRef;
            }
        }

        private CodeFieldReferenceExpression ComplexPropertyInitializedFieldRef
        {
            get
            {
                if (_complexPropertyInitializedFieldRef == null)
                    _complexPropertyInitializedFieldRef = new CodeFieldReferenceExpression(ThisRef, ComplexPropertyInitializedFieldName);

                return _complexPropertyInitializedFieldRef;
            }
        }

        private string FieldName
        {
            get
            {
                return Utils.FieldNameFromPropName(PropertyName);
            }
        }

        private string ComplexPropertyInitializedFieldName
        {
            get
            {
                return Utils.ComplexPropertyInitializedNameFromPropName(PropertyName);
            }
        }

        internal bool IsKeyProperty
        {
            get
            {
                EntityType entity = Item.DeclaringType as EntityType;
                if (entity != null)
                {
                    return entity.KeyMembers.Contains(Item.Name);
                }
                return false;
            }
        }

        internal static bool HasDefault(EdmProperty property)
        {
            return property.DefaultValue != null;
        }

        private CodeExpression GetDefaultValueExpression(EdmProperty property)
        {
            PrimitiveTypeKind type;
            object value = property.DefaultValue;
            if (value != null
                 && Utils.TryGetPrimitiveTypeKind(property.TypeUsage.EdmType, out type))
            {
                if (!property.Nullable && value.Equals(TypeSystem.GetDefaultValue(value.GetType())))
                {
                    return null;
                }

                switch (type)
                {
                    case PrimitiveTypeKind.Boolean:
                    case PrimitiveTypeKind.Byte:
                    case PrimitiveTypeKind.Int16:
                    case PrimitiveTypeKind.Int32:
                    case PrimitiveTypeKind.Int64:
                    case PrimitiveTypeKind.Decimal:
                    case PrimitiveTypeKind.Single:
                    case PrimitiveTypeKind.Double:
                    case PrimitiveTypeKind.String:
                        {
                            return new CodePrimitiveExpression(value);
                        }
                    case PrimitiveTypeKind.Guid:
                        {
                            return GetCodeExpressionFromGuid(value);
                        }
                    case PrimitiveTypeKind.DateTime:
                        {
                            return GetCodeExpressionFromDateTimeDefaultValue(value, property);
                        }
                    case PrimitiveTypeKind.DateTimeOffset:
                        {
                            return GetCodeExpressionFromDateTimeOffsetDefaultValue(value, property);
                        }
                    case PrimitiveTypeKind.Time:
                        {
                            return GetCodeExpressionFromTimeSpanDefaultValue(value, property);
                        }
                    case PrimitiveTypeKind.Binary:
                        {
                            return GetCodeExpressionFromBinary(value);
                        }
                    default:
                        Debug.Fail("Unsupported property type:" + type.ToString());
                        break;
                }
                return null;
            }
            return null;
        }

        private CodeExpression GetCodeExpressionFromBinary(object value)
        {
            byte[] data = (byte[])value;
            CodeExpression[] bytes = new CodeExpression[data.Length];

            for (int iByte = 0; iByte < data.Length; ++iByte)
            {
                bytes[iByte] = new CodePrimitiveExpression(data[iByte]);
            }

            return new CodeArrayCreateExpression(TypeReference.ByteArray, bytes);
        }

        private CodeExpression GetCodeExpressionFromGuid(object value)
        {
            Guid guid = (Guid)value;
            return new CodeObjectCreateExpression(TypeReference.Guid,
                new CodePrimitiveExpression(guid.ToString("D", CultureInfo.InvariantCulture)));
        }

        private CodeExpression GetCodeExpressionFromDateTimeDefaultValue(object value, EdmProperty property)
        {
            DateTime utc = (DateTime)value;
            DateTime dateTime = DateTime.SpecifyKind(utc, DateTimeKind.Unspecified);

            return new CodeObjectCreateExpression(TypeReference.DateTime, new CodePrimitiveExpression(dateTime.Ticks), GetEnumValue(DateTimeKind.Unspecified));
        }

        private CodeExpression GetCodeExpressionFromDateTimeOffsetDefaultValue(object value, EdmProperty property)
        {
            DateTimeOffset dateTimeOffset = (DateTimeOffset)value;

            return new CodeObjectCreateExpression(TypeReference.DateTimeOffset, new CodePrimitiveExpression(dateTimeOffset.Ticks),
                new CodeObjectCreateExpression(TypeReference.TimeSpan, new CodePrimitiveExpression(dateTimeOffset.Offset.Ticks)));
        }

        private CodeExpression GetCodeExpressionFromTimeSpanDefaultValue(object value, EdmProperty property)
        {
            TimeSpan timeSpan = (TimeSpan)value;
            return new CodeObjectCreateExpression(TypeReference.TimeSpan, new CodePrimitiveExpression(timeSpan.Ticks));
        }

        public bool IsVirtualProperty
        {
            get
            {
                return false;
            }
        }

        private struct PropertyTypeReferences
        {
            CodeTypeReference _nonNullable;
            CodeTypeReference _nullable;
            public PropertyTypeReferences(TypeReference typeReference, PrimitiveType primitiveType)
                : this(typeReference, primitiveType, CollectionKind.None)
            {
            }

            public PropertyTypeReferences(TypeReference typeReference, PrimitiveType primitiveType, CollectionKind collectionKind)
            {
                Type type = primitiveType.ClrEquivalentType;
                if (collectionKind == CollectionKind.None)
                {
                    _nonNullable = typeReference.ForType(type);
                    if (type.IsValueType)
                    {
                        _nullable = typeReference.NullableForType(type);
                    }
                    else
                    {
                        _nullable = typeReference.ForType(type);
                    }
                }
                else
                {
                    CodeTypeReference primitiveTypeRef = typeReference.ForType(type);
                    CodeTypeReference collectionType = GetCollectionTypeReference(typeReference, primitiveTypeRef, collectionKind);
                    _nonNullable = collectionType;
                    _nullable = collectionType;
                }
            }

            public PropertyTypeReferences(TypeReference typeReference, ComplexType complexType, CollectionKind collectionKind, ClientApiGenerator generator)
            {
                CodeTypeReference baseType = generator.GetLeastPossibleQualifiedTypeReference(complexType);
                baseType = GetCollectionTypeReference(typeReference, baseType, collectionKind);
                _nonNullable = baseType;
                _nullable = baseType;
            }

            private static CodeTypeReference GetCollectionTypeReference(TypeReference typeReference, CodeTypeReference baseType, CollectionKind collectionKind)
            {
                if (collectionKind == CollectionKind.Bag)
                {
                    baseType = GetCollectionTypeReferenceForBagSemantics(typeReference, baseType);
                }
                else if (collectionKind == CollectionKind.List)
                {
                    baseType = GetCollectionTypeReferenceForListSemantics(typeReference, baseType);
                }
                else
                {
                    Debug.Assert(collectionKind == CollectionKind.None, "Was another CollectionKind value added");
                    // nothing more to do for .None
                }
                return baseType;
            }

            public PropertyTypeReferences(TypeReference typeReference, ComplexType complexType, ClientApiGenerator generator)
                : this(typeReference, complexType, CollectionKind.None, generator)
            {
            }

            private static CodeTypeReference GetCollectionTypeReferenceForBagSemantics(TypeReference typeReference, CodeTypeReference baseType)
            {
                CodeTypeReference typeRef = typeReference.ForType(typeof(System.Collections.Generic.ICollection<>), baseType);
                return typeRef;
            }

            private static CodeTypeReference GetCollectionTypeReferenceForListSemantics(TypeReference typeReference, CodeTypeReference baseType)
            {
                CodeTypeReference typeRef = typeReference.ForType(typeof(System.Collections.Generic.IList<>), baseType);
                return typeRef;
            }

            public CodeTypeReference NonNullable
            {
                get { return _nonNullable; }
            }
            public CodeTypeReference Nullable
            {
                get { return _nullable; }
            }
        }
        #endregion

        // properties from ClassPropertyEmitter

        public string PropertyFQName
        {
            get
            {
                return Item.DeclaringType.FullName + "." + Item.Name;
            }
        }

        public string PropertyName
        {
            get
            {
                return EntityPropertyName;
            }
        }

        private string PropertyClassName
        {
            get
            {
                return Item.DeclaringType.Name;
            }
        }

        private CodeMemberProperty EmitPropertyDeclaration(MemberAttributes scope, CodeTypeReference propertyType, bool isVirtual,
            bool hidesBaseProperty)
        {
            Debug.Assert(GetAccessibilityRank(scope) >= 0, "scope should only be an accessibility attribute");

            CodeMemberProperty memberProperty = new CodeMemberProperty();
            memberProperty.Name = PropertyName;
            CommentEmitter.EmitSummaryComments(Item, memberProperty.Comments);

            memberProperty.Attributes = scope;

            if (!isVirtual)
            {
                memberProperty.Attributes |= MemberAttributes.Final;
            }

            if (hidesBaseProperty || AncestorClassDefinesName(memberProperty.Name))
            {
                memberProperty.Attributes |= MemberAttributes.New;
            }

            memberProperty.Type = propertyType;

            return memberProperty;
        }

        private void DisallowReturnTypeChange(CodeTypeReference baseType, CodeTypeReference newType)
        {
            if (Helper.IsCollectionType(Item.TypeUsage.EdmType) && GetCollectionKind(Item.TypeUsage) != CollectionKind.None)
            {
                if (newType == null)
                {
                    throw EDesignUtil.InvalidOperation(Strings.CannotChangePropertyReturnTypeToNull(Item.Name, Item.DeclaringType.Name));
                }

                // you can change the return type of collection properties
                // we don't even need to check
                return;
            }

            if (!(baseType == null && newType == null) &&
                (
                    (baseType != null && !baseType.Equals(newType)) ||
                    (newType != null && !newType.Equals(baseType))
                )
               )
            {
                throw EDesignUtil.InvalidOperation(Strings.CannotChangePropertyReturnType(Item.Name, Item.DeclaringType.Name));
            }
        }
    }
}