//------------------------------------------------------------------------------
// <copyright file="MemberRelationshipService.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------
namespace System.ComponentModel.Design.Serialization {
    using System.Collections.Generic;
    using System.Diagnostics.CodeAnalysis;
    using System.Security.Permissions;

    /// <devdoc>
    ///    A member relationship service is used by a serializer to announce that one
    ///    property is related to a property on another object. Consider a code
    ///    based serialization scheme where code is of the following form:
    /// 
    ///    object1.Property1 = object2.Property2
    /// 
    ///    Upon interpretation of this code, Property1 on object1 will be
    ///    set to the return value of object2.Property2.  But the relationship
    ///    between these two objects is lost.  Serialization schemes that
    ///    wish to maintain this relationship may install a MemberRelationshipService
    ///    into the serialization manager.  When an object is deserialized
    ///    this serivce will be notified of these relationships.  It is up to the service
    ///    to act on these notifications if it wishes.  During serialization, the
    ///    service is also consulted.  If a relationship exists the same
    ///    relationship is maintained by the serializer.
    /// </devdoc>
    [HostProtection(SharedState = true)]
    public abstract class MemberRelationshipService
    {
        private Dictionary<RelationshipEntry,RelationshipEntry> _relationships = new Dictionary<RelationshipEntry,RelationshipEntry>();

        /// <devdoc>
        ///    Returns the the current relationship associated with the source, or MemberRelationship.Empty if
        ///    there is no relationship.  Also sets a relationship between two objects.  Empty
        ///    can also be passed as the property value, in which case the relationship will
        ///    be cleared.
        /// </devdoc>
        [SuppressMessage("Microsoft.Design", "CA1043:UseIntegralOrStringArgumentForIndexers")]
        public MemberRelationship this[MemberRelationship source] {
            get {
                if (source.Owner == null) throw new ArgumentNullException("Owner");
                if (source.Member== null) throw new ArgumentNullException("Member");

                return GetRelationship(source);
            }
            set {
                if (source.Owner == null) throw new ArgumentNullException("Owner");
                if (source.Member == null) throw new ArgumentNullException("Member");

                SetRelationship(source, value);
            }
        }

        /// <devdoc>
        ///    Returns the the current relationship associated with the source, or null if
        ///    there is no relationship.  Also sets a relationship between two objects.  Null
        ///    can be passed as the property value, in which case the relationship will
        ///    be cleared.
        /// </devdoc>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1023:IndexersShouldNotBeMultidimensional")]
        public MemberRelationship this[object sourceOwner, MemberDescriptor sourceMember] {
            get {
                if (sourceOwner == null) throw new ArgumentNullException("sourceOwner");
                if (sourceMember == null) throw new ArgumentNullException("sourceMember");

                return GetRelationship(new MemberRelationship(sourceOwner, sourceMember));
            }
            set {
                if (sourceOwner == null) throw new ArgumentNullException("sourceOwner");
                if (sourceMember == null) throw new ArgumentNullException("sourceMember");

                SetRelationship(new MemberRelationship(sourceOwner, sourceMember), value);
            }
        }

        /// <devdoc>
        ///    This is the implementation API for returning relationships.  The default implementation stores the 
        ///    relationship in a table.  Relationships are stored weakly, so they do not keep an object alive.
        /// </devdoc>
        protected virtual MemberRelationship GetRelationship(MemberRelationship source) {
            RelationshipEntry retVal;

            if (_relationships != null && _relationships.TryGetValue(new RelationshipEntry(source), out retVal) && retVal.Owner.IsAlive) {
                return new MemberRelationship(retVal.Owner.Target, retVal.Member);
            }

            return MemberRelationship.Empty;
        }

        /// <devdoc>
        ///    This is the implementation API for returning relationships.  The default implementation stores the 
        ///    relationship in a table.  Relationships are stored weakly, so they do not keep an object alive.  Empty can be
        ///    passed in for relationship to remove the relationship.
        /// </devdoc>
        protected virtual void SetRelationship(MemberRelationship source, MemberRelationship relationship) {

            if (!relationship.IsEmpty && !SupportsRelationship(source, relationship)) {
                string sourceName = TypeDescriptor.GetComponentName(source.Owner);
                string relName = TypeDescriptor.GetComponentName(relationship.Owner);
                if (sourceName == null) {
                    sourceName = source.Owner.ToString();
                }
                if (relName == null) {
                    relName = relationship.Owner.ToString();
                }
                throw new ArgumentException(SR.GetString(SR.MemberRelationshipService_RelationshipNotSupported, sourceName, source.Member.Name, relName, relationship.Member.Name));
            }

            if (_relationships == null) {
                _relationships = new Dictionary<RelationshipEntry,RelationshipEntry>();
            }

            _relationships[new RelationshipEntry(source)] = new RelationshipEntry(relationship);
        }

        /// <devdoc>
        ///    Returns true if the provided relatinoship is supported.
        /// </devdoc>
        public abstract bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship);

        /// <devdoc>
        ///    Used as storage in our relationship table
        /// </devdoc>
        private struct RelationshipEntry {
            internal WeakReference Owner;
            internal MemberDescriptor Member;
            private int hashCode;

            internal RelationshipEntry(MemberRelationship rel) {
                Owner = new WeakReference(rel.Owner);
                Member = rel.Member;
                hashCode = rel.Owner == null ? 0 : rel.Owner.GetHashCode();
            }


            public override bool Equals(object o) {
                if (o is RelationshipEntry) {
                    RelationshipEntry e = (RelationshipEntry)o;
                    return this == e;
                }

                return false;
            }

            public static bool operator==(RelationshipEntry re1, RelationshipEntry re2){
                object owner1 = (re1.Owner.IsAlive ? re1.Owner.Target : null);
                object owner2 = (re2.Owner.IsAlive ? re2.Owner.Target : null);
                return owner1 == owner2 && re1.Member.Equals(re2.Member);
            }

            public static bool operator!=(RelationshipEntry re1, RelationshipEntry re2){
                return !(re1 == re2);
            }

            public override int GetHashCode() {
                return hashCode;
            }
        }
    }

    /// <devdoc>
    ///    This class represents a single relationship between an object and a member.
    /// </devdoc>
    public struct MemberRelationship {
        private object _owner;
        private MemberDescriptor _member;

        public static readonly MemberRelationship Empty = new MemberRelationship();

        /// <devdoc>
        ///    Creates a new member relationship.
        /// </devdoc>
        public MemberRelationship(object owner, MemberDescriptor member) {
            if (owner == null) throw new ArgumentNullException("owner");
            if (member == null) throw new ArgumentNullException("member");

            _owner = owner;
            _member = member;
        }

        /// <devdoc>
        ///    Returns true if this relationship is empty.
        /// </devdoc>
        public bool IsEmpty {
            get {
                return _owner == null;
            }
        }

        /// <devdoc>
        ///    The member in this relationship.
        /// </devdoc>
        public MemberDescriptor Member {
            get {
                return _member;
            }
        }

        /// <devdoc>
        ///    The object owning the member.
        /// </devdoc>
        public object Owner {
            get {
                return _owner;
            }
        }

        /// <devdoc>
        ///    Infrastructure support to make this a first class struct
        /// </devdoc>
        public override bool Equals(object obj) {
            if (!(obj is MemberRelationship))
                return false;

            MemberRelationship rel = (MemberRelationship)obj;
            return rel.Owner == Owner && rel.Member == Member;
        }

        /// <devdoc>
        ///    Infrastructure support to make this a first class struct
        /// </devdoc>
        public override int GetHashCode() {
            if (_owner == null) return base.GetHashCode();
            return _owner.GetHashCode() ^ _member.GetHashCode();
        }
        /// <devdoc>
        ///    Infrastructure support to make this a first class struct
        /// </devdoc>
        public static bool operator ==(MemberRelationship left, MemberRelationship right) {
            return left.Owner == right.Owner && left.Member == right.Member;
        }

        /// <devdoc>
        ///    Infrastructure support to make this a first class struct
        /// </devdoc>
        public static bool operator !=(MemberRelationship left, MemberRelationship right) {
            return !(left == right);
        }
    }
}