//---------------------------------------------------------------------
// <copyright file="RelationshipEntry.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner       [....]
// @backupOwner [....]
//---------------------------------------------------------------------
namespace System.Data.Objects
{
    using System;
    using System.Collections.Generic;
    using System.Data.Common;
    using System.Data.Metadata.Edm;
    using System.Data.Objects.DataClasses;
    using System.Data.Objects.Internal;
    using System.Diagnostics;

    internal sealed class RelationshipEntry : ObjectStateEntry
    {
        internal RelationshipWrapper _relationshipWrapper;
        internal EntityKey Key0 { get { return RelationshipWrapper.Key0; } }
        internal EntityKey Key1 { get { return RelationshipWrapper.Key1; } }
        internal override System.Collections.BitArray ModifiedProperties
        {
            get { return null; }
        }

        #region Linked list of related relationships
        private RelationshipEntry _nextKey0;
        private RelationshipEntry _nextKey1;
        #endregion

        #region Constructors
        internal RelationshipEntry(ObjectStateManager cache, EntityState state, RelationshipWrapper relationshipWrapper)
            : base(cache, null, state)
        {
            Debug.Assert(null != relationshipWrapper, "null RelationshipWrapper");
            Debug.Assert(EntityState.Added == state ||
                         EntityState.Unchanged == state ||
                         EntityState.Deleted == state,
                         "invalid EntityState");

            base._entitySet = relationshipWrapper.AssociationSet;
            _relationshipWrapper = relationshipWrapper;
        }
        #endregion

        #region Public members

        /// <summary>
        /// API to accept the current values as original values and  mark the entity as Unchanged.
        /// </summary>
        /// <param></param>
        /// <returns></returns>
        override public bool IsRelationship
        {
            get
            {
                ValidateState();
                return true;
            }
        }

        override public void AcceptChanges()
        {
            ValidateState();

            switch (State)
            {
                case EntityState.Deleted:
                    DeleteUnnecessaryKeyEntries();
                    // Current entry could be already detached if this is relationship entry and if one end of relationship was a KeyEntry
                    if (_cache != null)
                    {
                        _cache.ChangeState(this, EntityState.Deleted, EntityState.Detached);
                    }
                    break;
                case EntityState.Added:
                    _cache.ChangeState(this, EntityState.Added, EntityState.Unchanged);
                    State = EntityState.Unchanged;
                    break;
                case EntityState.Modified:
                    Debug.Assert(false, "RelationshipEntry cannot be in Modified state");
                    break;
                case EntityState.Unchanged:
                    break;
            }
        }

        override public void Delete()
        {
            // doFixup flag is used for Cache and Collection & Ref consistency
            // When some entity is deleted if "doFixup" is true then Delete method
            // calls the Collection & Ref code to do the necessary fix-ups.
            // "doFixup" equals to False is only called from EntityCollection & Ref code
            Delete(/*doFixup*/true);
        }

        override public IEnumerable<string> GetModifiedProperties()
        {
            ValidateState();
            yield break;
        }

        override public void SetModified()
        {
            ValidateState();
            throw EntityUtil.CantModifyRelationState();
        }

        override public object Entity
        {
            get
            {
                ValidateState();
                return null;
            }
        }

        override public EntityKey EntityKey
        {
            get
            {
                ValidateState();
                return null;
            }
            internal set
            {
                // no-op for entires other than EntityEntry
                Debug.Assert(false, "EntityKey setter shouldn't be called for RelationshipEntry");
            }
        }

        /// <summary>
        /// Marks specified property as modified.
        /// </summary>
        /// <param name="propertyName">This API recognizes the names in terms of OSpace</param>
        /// <exception cref="InvalidOperationException">If State is not Modified or Unchanged</exception>
        ///
        override public void SetModifiedProperty(string propertyName)
        {
            ValidateState();

            throw EntityUtil.CantModifyRelationState();
        }

        /// <summary>
        /// Throws since the method has no meaning for relationship entries.
        /// </summary>
        override public void RejectPropertyChanges(string propertyName)
        {
            ValidateState();

            throw EntityUtil.CantModifyRelationState();
        }

        /// <summary>
        /// Throws since the method has no meaning for relationship entries.
        /// </summary>
        public override bool IsPropertyChanged(string propertyName)
        {
            ValidateState();

            throw EntityUtil.CantModifyRelationState();
        }

        /// <summary>
        /// Original values of entity
        /// </summary>
        /// <param></param>
        /// <returns> DbDataRecord </returns>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)] // don't have debugger view expand this
        override public DbDataRecord OriginalValues
        {
            get
            {
                ValidateState();
                if (this.State == EntityState.Added)
                {
                    throw EntityUtil.OriginalValuesDoesNotExist();
                }

                return new ObjectStateEntryDbDataRecord(this);
            }        
        }

        public override OriginalValueRecord GetUpdatableOriginalValues()
        {
            throw EntityUtil.CantModifyRelationValues();
        }

        /// <summary>
        /// Current values of entity/ DataRow
        /// </summary>
        /// <param></param>
        /// <returns> DbUpdatableDataRecord </returns>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)] // don't have debugger view expand this
        override public CurrentValueRecord CurrentValues
        {
            get
            {
                ValidateState();
                if (this.State == EntityState.Deleted)
                {
                    throw EntityUtil.CurrentValuesDoesNotExist();
                }

                return new ObjectStateEntryDbUpdatableDataRecord(this);
            }
        }

        override public RelationshipManager RelationshipManager
        {
            get
            {
                throw new InvalidOperationException(System.Data.Entity.Strings.ObjectStateEntry_RelationshipAndKeyEntriesDoNotHaveRelationshipManagers);
            }
        }

        public override void ChangeState(EntityState state)
        {
            EntityUtil.CheckValidStateForChangeRelationshipState(state, "state");

            if (this.State == EntityState.Detached && state == EntityState.Detached)
            {
                return;
            }

            ValidateState();

            if (this.RelationshipWrapper.Key0 == this.Key0)
            {
                this.ObjectStateManager.ChangeRelationshipState(
                    this.Key0, this.Key1,
                    this.RelationshipWrapper.AssociationSet.ElementType.FullName,
                    this.RelationshipWrapper.AssociationEndMembers[1].Name,
                    state);
            }
            else
            {
                Debug.Assert(this.RelationshipWrapper.Key0 == this.Key1, "invalid relationship");
                this.ObjectStateManager.ChangeRelationshipState(
                    this.Key0, this.Key1,
                    this.RelationshipWrapper.AssociationSet.ElementType.FullName,
                    this.RelationshipWrapper.AssociationEndMembers[0].Name,
                    state);
            }
        }

        public override void ApplyCurrentValues(object currentEntity)
        {
            throw EntityUtil.CantModifyRelationValues();
        }

        public override void ApplyOriginalValues(object originalEntity)
        {
            throw EntityUtil.CantModifyRelationValues();
        }

        #endregion

        #region ObjectStateEntry members

        override internal bool IsKeyEntry
        {
            get
            {
                return false;
            }
        }

        override internal int GetFieldCount(StateManagerTypeMetadata metadata)
        {
            return _relationshipWrapper.AssociationEndMembers.Count;
        }

        /// <summary>
        /// Reuse or create a new (Entity)DataRecordInfo.
        /// </summary>
        override internal DataRecordInfo GetDataRecordInfo(StateManagerTypeMetadata metadata, object userObject)
        {
            //Dev Note: RelationshipType always has default facets. Thus its safe to construct a TypeUsage from EdmType
            return new DataRecordInfo(TypeUsage.Create(((RelationshipSet)EntitySet).ElementType));
        }

        override internal void SetModifiedAll()
        {
            ValidateState();
            throw EntityUtil.CantModifyRelationState();
        }

        override internal Type GetFieldType(int ordinal, StateManagerTypeMetadata metadata)
        {
            // 'metadata' is used for ComplexTypes in EntityEntry

            return typeof(EntityKey); // this is given By Design
        }

        override internal string GetCLayerName(int ordinal, StateManagerTypeMetadata metadata)
        {
            ValidateRelationshipRange(ordinal);
            return _relationshipWrapper.AssociationEndMembers[ordinal].Name;
        }

        override internal int GetOrdinalforCLayerName(string name, StateManagerTypeMetadata metadata)
        {
            AssociationEndMember endMember;
            ReadOnlyMetadataCollection<AssociationEndMember> endMembers = _relationshipWrapper.AssociationEndMembers;
            if (endMembers.TryGetValue(name, false, out endMember))
            {
                return endMembers.IndexOf(endMember);
            }
            return -1;
        }

        override internal void RevertDelete()
        {
            State = EntityState.Unchanged;
            _cache.ChangeState(this, EntityState.Deleted, State);
        }

        /// <summary>
        /// Used to report that a scalar entity property is about to change
        /// The current value of the specified property is cached when this method is called.
        /// </summary>
        /// <param name="entityMemberName">The name of the entity property that is changing</param>
        override internal void EntityMemberChanging(string entityMemberName)
        {
            throw EntityUtil.CantModifyRelationValues();
        }

        /// <summary>
        /// Used to report that a scalar entity property has been changed
        /// The property value that was cached during EntityMemberChanging is now
        /// added to OriginalValues
        /// </summary>
        /// <param name="entityMemberName">The name of the entity property that has changing</param>
        override internal void EntityMemberChanged(string entityMemberName)
        {
            throw EntityUtil.CantModifyRelationValues();
        }

        /// <summary>
        /// Used to report that a complex property is about to change
        /// The current value of the specified property is cached when this method is called.
        /// </summary>
        /// <param name="entityMemberName">The name of the top-level entity property that is changing</param>
        /// <param name="complexObject">The complex object that contains the property that is changing</param>
        /// <param name="complexObjectMemberName">The name of the property that is changing on complexObject</param>
        override internal void EntityComplexMemberChanging(string entityMemberName, object complexObject, string complexObjectMemberName)
        {
            throw EntityUtil.CantModifyRelationValues();
        }

        /// <summary>
        /// Used to report that a complex property has been changed
        /// The property value that was cached during EntityMemberChanging is now added to OriginalValues
        /// </summary>
        /// <param name="entityMemberName">The name of the top-level entity property that has changed</param>
        /// <param name="complexObject">The complex object that contains the property that changed</param>
        /// <param name="complexObjectMemberName">The name of the property that changed on complexObject</param>
        override internal void EntityComplexMemberChanged(string entityMemberName, object complexObject, string complexObjectMemberName)
        {
            throw EntityUtil.CantModifyRelationValues();
        }

        #endregion

        // Helper method to determine if the specified entityKey is in the given role and AssociationSet in this relationship entry
        internal bool IsSameAssociationSetAndRole(AssociationSet associationSet, AssociationEndMember associationMember, EntityKey entityKey)
        {
            Debug.Assert(associationSet.ElementType.AssociationEndMembers[0].Name == associationMember.Name ||
                         associationSet.ElementType.AssociationEndMembers[1].Name == associationMember.Name,
                         "Expected associationMember to be one of the ends of the specified associationSet.");

            if (!Object.ReferenceEquals(_entitySet, associationSet))
            {
                return false;
            }

            // Find the end of the relationship that corresponds to the associationMember and see if it matches the EntityKey we are looking for
            if (_relationshipWrapper.AssociationSet.ElementType.AssociationEndMembers[0].Name == associationMember.Name)
            {
                return entityKey == Key0;
            }
            else
            {
                return entityKey == Key1;
            }
        }

        private object GetCurrentRelationValue(int ordinal, bool throwException)
        {
            ValidateRelationshipRange(ordinal);
            ValidateState();
            if (State == EntityState.Deleted && throwException)
            {
                throw EntityUtil.CurrentValuesDoesNotExist();
            }
            return _relationshipWrapper.GetEntityKey(ordinal);
        }

        private static void ValidateRelationshipRange(int ordinal)
        {
            if (unchecked(1u < (uint)ordinal))
            {
                throw EntityUtil.ArgumentOutOfRange("ordinal");
            }
        }

        internal object GetCurrentRelationValue(int ordinal)
        {
            return GetCurrentRelationValue(ordinal, true);
        }

        internal RelationshipWrapper RelationshipWrapper
        {
            get
            {
                return _relationshipWrapper;
            }
            set
            {
                Debug.Assert(null != value, "don't set wrapper to null");
                _relationshipWrapper = value;
            }
        }

        override internal void Reset()
        {
            _relationshipWrapper = null;

            base.Reset();
        }

        /// <summary>
        /// Update one of the ends of the relationship
        /// </summary>
        internal void ChangeRelatedEnd(EntityKey oldKey, EntityKey newKey)
        {
            if (oldKey.Equals(Key0))
            {
                if (oldKey.Equals(Key1))
                {   // self-reference
                    RelationshipWrapper = new RelationshipWrapper(RelationshipWrapper.AssociationSet, newKey);
                }
                else
                {
                    RelationshipWrapper = new RelationshipWrapper(RelationshipWrapper, 0, newKey);
                }
            }
            else
            {
                RelationshipWrapper = new RelationshipWrapper(RelationshipWrapper, 1, newKey);
            }
        }

        internal void DeleteUnnecessaryKeyEntries()
        {
            // We need to check to see if the ends of the relationship are key entries.
            // If they are, and nothing else refers to them then the key entry should be removed.
            for (int i = 0; i < 2; i++)
            {
                EntityKey entityKey = this.GetCurrentRelationValue(i, false) as EntityKey;
                EntityEntry relatedEntry = _cache.GetEntityEntry(entityKey);
                if (relatedEntry.IsKeyEntry)
                {
                    bool foundRelationship = false;
                    // count the number of relationships this key entry is part of
                    // if there aren't any, then the relationship should be deleted
                    foreach (RelationshipEntry relationshipEntry in _cache.FindRelationshipsByKey(entityKey))
                    {
                        // only count relationships that are not the one we are currently deleting (i.e. this)
                        if (relationshipEntry != this)
                        {
                            foundRelationship = true;
                            break;
                        }
                    }
                    if (!foundRelationship)
                    {
                        // Nothing is refering to this key entry, so it should be removed from the cache
                        _cache.DeleteKeyEntry(relatedEntry);
                        // We assume that only one end of relationship can be a key entry,
                        // so we can break the loop
                        break;
                    }
                }
            }
        }

        //"doFixup" equals to False is called from EntityCollection & Ref code only
        internal void Delete(bool doFixup)
        {
            ValidateState();

            if (doFixup)
            {
                if (State != EntityState.Deleted)  //for deleted ObjectStateEntry its a no-op
                {
                    //Find two ends of the relationship
                    EntityEntry entry1 = _cache.GetEntityEntry((EntityKey)GetCurrentRelationValue(0));
                    IEntityWrapper wrappedEntity1 = entry1.WrappedEntity;
                    EntityEntry entry2 = _cache.GetEntityEntry((EntityKey)GetCurrentRelationValue(1));
                    IEntityWrapper wrappedEntity2 = entry2.WrappedEntity;

                    // If one end of the relationship is a KeyEntry, entity1 or entity2 is null.
                    // It is not possible that both ends of relationship are KeyEntries.
                    if (wrappedEntity1.Entity != null && wrappedEntity2.Entity != null)
                    {
                        // Obtain the ro role name and relationship name
                        // We don't create a full NavigationRelationship here because that would require looking up
                        // additional information like property names that we don't need.
                        ReadOnlyMetadataCollection<AssociationEndMember> endMembers = _relationshipWrapper.AssociationEndMembers;
                        string toRole = endMembers[1].Name;
                        string relationshipName = ((AssociationSet)_entitySet).ElementType.FullName;
                        wrappedEntity1.RelationshipManager.RemoveEntity(toRole, relationshipName, wrappedEntity2);
                    }
                    else
                    {
                        // One end of relationship is a KeyEntry, figure out which one is the real entity and get its RelationshipManager
                        // so we can update the DetachedEntityKey on the EntityReference associated with this relationship
                        EntityKey targetKey = null;
                        RelationshipManager relationshipManager = null;
                        if (wrappedEntity1.Entity == null)
                        {
                            targetKey = entry1.EntityKey;
                            relationshipManager = wrappedEntity2.RelationshipManager;
                        }
                        else
                        {
                            targetKey = entry2.EntityKey;
                            relationshipManager = wrappedEntity1.RelationshipManager;
                        }
                        Debug.Assert(relationshipManager != null, "Entity wrapper returned a null RelationshipManager");

                        // Clear the detachedEntityKey as well. In cases where we have to fix up the detachedEntityKey, we will not always be able to detect
                        // if we have *only* a Deleted relationship for a given entity/relationship/role, so clearing this here will ensure that
                        // even if no other relationships are added, the key value will still be correct and we won't accidentally pick up an old value.

                        // devnote: Since we know the target end of this relationship is a key entry, it has to be a reference, so just cast
                        AssociationEndMember targetMember = this.RelationshipWrapper.GetAssociationEndMember(targetKey);
                        EntityReference entityReference = (EntityReference)relationshipManager.GetRelatedEndInternal(targetMember.DeclaringType.FullName, targetMember.Name);
                        entityReference.DetachedEntityKey = null;

                        // Now update the state
                        if (this.State == EntityState.Added)
                        {
                            // Remove key entry if necessary
                            DeleteUnnecessaryKeyEntries();
                            // Remove relationship entry
                            // devnote: Using this method instead of just changing the state because the entry
                            //          may have already been detached along with the key entry above. However,
                            //          if there were other relationships using the key, it would not have been deleted.
                            DetachRelationshipEntry();
                        }
                        else
                        {
                            // Non-added entries should be deleted
                            _cache.ChangeState(this, this.State, EntityState.Deleted);
                            State = EntityState.Deleted;
                        }
                    }
                }
            }
            else
            {
                switch (State)
                {
                    case EntityState.Added:
                        // Remove key entry if necessary
                        DeleteUnnecessaryKeyEntries();
                        // Remove relationship entry
                        // devnote: Using this method instead of just changing the state because the entry
                        //          may have already been detached along with the key entry above. However,
                        //          if there were other relationships using the key, it would not have been deleted.
                        DetachRelationshipEntry();
                        break;
                    case EntityState.Modified:
                        Debug.Assert(false, "RelationshipEntry cannot be in Modified state");
                        break;
                    case EntityState.Unchanged:
                        _cache.ChangeState(this, EntityState.Unchanged, EntityState.Deleted);
                        State = EntityState.Deleted;
                        break;
                    //case DataRowState.Deleted:  no-op
                }
            }
        }

        internal object GetOriginalRelationValue(int ordinal)
        {
            return GetCurrentRelationValue(ordinal, false);
        }

        internal void DetachRelationshipEntry()
        {
            // no-op if already detached
            if (_cache != null)
            {
                _cache.ChangeState(this, this.State, EntityState.Detached);
            }
        }

        internal void ChangeRelationshipState(EntityEntry targetEntry, RelatedEnd relatedEnd, EntityState requestedState)
        {
            Debug.Assert(requestedState != EntityState.Modified, "Invalid requested state for relationsihp");
            Debug.Assert(this.State != EntityState.Modified, "Invalid initial state for relationsihp");

            EntityState initialState = this.State;

            switch (initialState)
            {
                case EntityState.Added:
                    switch (requestedState)
                    {
                        case EntityState.Added:
                            // no-op
                            break;
                        case EntityState.Unchanged:
                            this.AcceptChanges();
                            break;
                        case EntityState.Deleted:
                            this.AcceptChanges();
                            // cascade deletion is not performed because TransactionManager.IsLocalPublicAPI == true
                            this.Delete();
                            break;
                        case EntityState.Detached:
                            // cascade deletion is not performed because TransactionManager.IsLocalPublicAPI == true
                            this.Delete();
                            break;
                        default:
                            Debug.Assert(false, "Invalid requested state");
                            break;
                    }
                    break;
                case EntityState.Unchanged:
                    switch (requestedState)
                    {
                        case EntityState.Added:
                            this.ObjectStateManager.ChangeState(this, EntityState.Unchanged, EntityState.Added);
                            this.State = EntityState.Added;
                            break;
                        case EntityState.Unchanged:
                            //no-op
                            break;
                        case EntityState.Deleted:
                            // cascade deletion is not performed because TransactionManager.IsLocalPublicAPI == true
                            this.Delete();
                            break;
                        case EntityState.Detached:
                            // cascade deletion is not performed because TransactionManager.IsLocalPublicAPI == true
                            this.Delete();
                            this.AcceptChanges();
                            break;
                        default:
                            Debug.Assert(false, "Invalid requested state");
                            break;
                    }
                    break;
                case EntityState.Deleted:
                    switch (requestedState)
                    {
                        case EntityState.Added:
                            relatedEnd.Add(targetEntry.WrappedEntity,
                                applyConstraints: true,   
                                addRelationshipAsUnchanged: false, 
                                relationshipAlreadyExists: true,   
                                allowModifyingOtherEndOfRelationship: false,
                                forceForeignKeyChanges: true); 
                            this.ObjectStateManager.ChangeState(this, EntityState.Deleted, EntityState.Added);
                            this.State = EntityState.Added;
                            break;
                        case EntityState.Unchanged:
                            relatedEnd.Add(targetEntry.WrappedEntity,
                                applyConstraints: true,
                                addRelationshipAsUnchanged: false,
                                relationshipAlreadyExists: true,
                                allowModifyingOtherEndOfRelationship: false,
                                forceForeignKeyChanges: true); 
                            this.ObjectStateManager.ChangeState(this, EntityState.Deleted, EntityState.Unchanged);
                            this.State = EntityState.Unchanged;
                            break;
                        case EntityState.Deleted:
                            // no-op
                            break;
                        case EntityState.Detached:
                            this.AcceptChanges();
                            break;
                        default:
                            Debug.Assert(false, "Invalid requested state");
                            break;
                    }
                    break;
                default:
                    Debug.Assert(false, "Invalid entry state");
                    break;
            }
        }


        #region RelationshipEnds as singly-linked list

        internal RelationshipEntry GetNextRelationshipEnd(EntityKey entityKey)
        {
            Debug.Assert(null != (object)entityKey, "null EntityKey");
            Debug.Assert(entityKey.Equals(Key0) || entityKey.Equals(Key1), "EntityKey mismatch");
            return (entityKey.Equals(Key0) ? NextKey0 : NextKey1);
        }

        internal void SetNextRelationshipEnd(EntityKey entityKey, RelationshipEntry nextEnd)
        {
            Debug.Assert(null != (object)entityKey, "null EntityKey");
            Debug.Assert(entityKey.Equals(Key0) || entityKey.Equals(Key1), "EntityKey mismatch");
            if (entityKey.Equals(Key0))
            {
                NextKey0 = nextEnd;
            }
            else
            {
                NextKey1 = nextEnd;
            }
        }

        /// <summary>
        /// Use when EntityEntry.EntityKey == this.Wrapper.Key0
        /// </summary>
        internal RelationshipEntry NextKey0
        {
            get { return _nextKey0; }
            set { _nextKey0 = value; }

        }

        /// <summary>
        /// Use when EntityEntry.EntityKey == this.Wrapper.Key1
        /// </summary>
        internal RelationshipEntry NextKey1
        {
            get { return _nextKey1; }
            set { _nextKey1 = value; }
        }
        #endregion
    }
}