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

namespace System.Web.UI.WebControls.WebParts {

    using System;
    using System.Collections;
    using System.ComponentModel;
    using System.Diagnostics;

    [
    TypeConverter(typeof(ExpandableObjectConverter)),
    ParseChildren(true, "Transformers")
    ]
    public sealed class WebPartConnection {

        private string _consumerConnectionPointID;
        private string _consumerID;
        private bool _deleted;
        private string _id;
        private bool _isActive;
        private bool _isShared;
        private bool _isStatic;
        private string _providerConnectionPointID;
        private string _providerID;
        private WebPartTransformerCollection _transformers;
        private WebPartManager _webPartManager;

        public WebPartConnection() {
            _isStatic = true;
            _isShared = true;
        }

        // PERF: Consider caching
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public WebPart Consumer {
            get {
                string consumerID = ConsumerID;
                if (consumerID.Length == 0) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_ConsumerIDNotSet));
                }

                if (_webPartManager != null) {
                    return _webPartManager.WebParts[consumerID];
                }
                else {
                    return null;
                }
            }
        }

        // PERF: Consider caching
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public ConsumerConnectionPoint ConsumerConnectionPoint {
            get {
                WebPart consumer = Consumer;
                if (consumer != null && _webPartManager != null) {
                    return _webPartManager.GetConsumerConnectionPoint(consumer, ConsumerConnectionPointID);
                }
                else {
                    return null;
                }
            }
        }

        [
        DefaultValue(ConnectionPoint.DefaultIDInternal)
        ]
        public string ConsumerConnectionPointID {
            get {
                // 
                return (!String.IsNullOrEmpty(_consumerConnectionPointID)) ?
                    _consumerConnectionPointID : ConnectionPoint.DefaultID;
            }
            set {
                _consumerConnectionPointID = value;
            }
        }

        [
        DefaultValue("")
        ]
        public string ConsumerID {
            get {
                return (_consumerID != null) ? _consumerID : String.Empty;
            }
            set {
                _consumerID = value;
            }
        }

        // True if this connection has been disconnected, but can not actually be removed.
        // Either a static or a shared connection.
        internal bool Deleted {
            get {
                return _deleted;
            }
            set {
                _deleted = value;
            }
        }

        [
        DefaultValue("")
        ]
        public string ID {
            get {
                return (_id != null) ? _id : String.Empty;
            }
            set {
                _id = value;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public bool IsActive {
            get {
                return _isActive;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public bool IsShared {
            get {
                return _isShared;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public bool IsStatic {
            get {
                return _isStatic;
            }
        }

        // PERF: Consider caching
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public WebPart Provider {
            get {
                string providerID = ProviderID;
                if (providerID.Length == 0) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartConnection_ProviderIDNotSet));
                }

                if (_webPartManager != null) {
                    return _webPartManager.WebParts[providerID];
                }
                else {
                    return null;
                }
            }
        }

        // PERF: Consider caching
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public ProviderConnectionPoint ProviderConnectionPoint {
            get {
                WebPart provider = Provider;
                if (provider != null && _webPartManager != null) {
                    return _webPartManager.GetProviderConnectionPoint(provider, ProviderConnectionPointID);
                }
                else {
                    return null;
                }
            }
        }

        [
        DefaultValue(ConnectionPoint.DefaultIDInternal)
        ]
        public string ProviderConnectionPointID {
            get {
                // 
                return (!String.IsNullOrEmpty(_providerConnectionPointID)) ?
                    _providerConnectionPointID : ConnectionPoint.DefaultID;
            }
            set {
                _providerConnectionPointID = value;
            }
        }

        [
        DefaultValue("")
        ]
        public string ProviderID {
            get {
                return (_providerID != null) ? _providerID : String.Empty;
            }
            set {
                _providerID = value;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
        ]
        public WebPartTransformer Transformer {
            get {
                if (_transformers == null || _transformers.Count == 0) {
                    return null;
                }
                else {
                    return _transformers[0];
                }
            }
        }

        /// <internalonly/>
        [
        Browsable(false),
        EditorBrowsable(EditorBrowsableState.Never),
        PersistenceMode(PersistenceMode.InnerDefaultProperty),
        ]
        public WebPartTransformerCollection Transformers {
            get {
                if (_transformers == null) {
                    _transformers = new WebPartTransformerCollection();
                }

                return _transformers;
            }
        }

        internal void Activate() {
            // This method should only be called on WebPartConnections in the WebPartManager, so
            // _webPartManager should never be null.
            Debug.Assert(_webPartManager != null);

            Transformers.SetReadOnly();

            WebPart providerWebPart = Provider;
            // Cannot be null because Activate() is only called on valid Connections
            Debug.Assert(providerWebPart != null);

            WebPart consumerWebPart = Consumer;
            // Cannot be null because Activate() is only called on valid Connections
            Debug.Assert(consumerWebPart != null);

            Control providerControl = providerWebPart.ToControl();
            Control consumerControl = consumerWebPart.ToControl();

            ProviderConnectionPoint providerConnectionPoint = ProviderConnectionPoint;
            // Cannot be null because Activate() is only called on valid Connections
            Debug.Assert(providerConnectionPoint != null);

            if (!providerConnectionPoint.GetEnabled(providerControl)) {
                consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_DisabledConnectionPoint, providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle));
                return;
            }

            ConsumerConnectionPoint consumerConnectionPoint = ConsumerConnectionPoint;
            // Cannot be null because Activate() is only called on valid Connections
            Debug.Assert(consumerConnectionPoint != null);

            if (!consumerConnectionPoint.GetEnabled(consumerControl)) {
                consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_DisabledConnectionPoint, consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle));
                return;
            }

            // Do not activate connections involving closed WebParts
            if (!providerWebPart.IsClosed && !consumerWebPart.IsClosed) {
                WebPartTransformer transformer = Transformer;
                if (transformer == null) {
                    if (providerConnectionPoint.InterfaceType == consumerConnectionPoint.InterfaceType) {
                        ConnectionInterfaceCollection secondaryInterfaces = providerConnectionPoint.GetSecondaryInterfaces(providerControl);
                        if (consumerConnectionPoint.SupportsConnection(consumerControl, secondaryInterfaces)) {
                            object dataObject = providerConnectionPoint.GetObject(providerControl);
                            consumerConnectionPoint.SetObject(consumerControl, dataObject);
                            _isActive = true;
                        }
                        else {
                            consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_IncompatibleSecondaryInterfaces, new string[] {
                                    consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle,
                                    providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle}));
                        }
                    }
                    else {
                        consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_NoCommonInterface, new string[] {
                                providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle,
                                consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle}));
                    }
                }
                else {
                    Type transformerType = transformer.GetType();

                    if (!_webPartManager.AvailableTransformers.Contains(transformerType)) {
                        string errorMessage;
                        if (_webPartManager.Context != null && _webPartManager.Context.IsCustomErrorEnabled) {
                            errorMessage = SR.GetString(SR.WebPartConnection_TransformerNotAvailable);
                        }
                        else {
                            errorMessage = SR.GetString(SR.WebPartConnection_TransformerNotAvailableWithType, transformerType.FullName);
                        }
                        consumerWebPart.SetConnectErrorMessage(errorMessage);
                        
                        // 
                    }

                    // Check matching interfaces on connection points and transformer attribute
                    Type transformerConsumerType = WebPartTransformerAttribute.GetConsumerType(transformerType);
                    Type transformerProviderType = WebPartTransformerAttribute.GetProviderType(transformerType);

                    if (providerConnectionPoint.InterfaceType == transformerConsumerType &&
                        transformerProviderType == consumerConnectionPoint.InterfaceType) {

                        // A transformer never provides any secondary interfaces
                        if (consumerConnectionPoint.SupportsConnection(consumerControl, ConnectionInterfaceCollection.Empty)) {
                            object dataObject = providerConnectionPoint.GetObject(providerControl);
                            object transformedObject = transformer.Transform(dataObject);
                            consumerConnectionPoint.SetObject(consumerControl, transformedObject);
                            _isActive = true;
                        }
                        else {
                            consumerWebPart.SetConnectErrorMessage(SR.GetString(SR.WebPartConnection_ConsumerRequiresSecondaryInterfaces,
                                consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle));
                        }
                    }
                    else if (providerConnectionPoint.InterfaceType != transformerConsumerType) {
                        string errorMessage;
                        if (_webPartManager.Context != null && _webPartManager.Context.IsCustomErrorEnabled) {
                            errorMessage = SR.GetString(SR.WebPartConnection_IncompatibleProviderTransformer,
                                providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle);
                        }
                        else {
                            errorMessage = SR.GetString(SR.WebPartConnection_IncompatibleProviderTransformerWithType,
                                providerConnectionPoint.DisplayName, providerWebPart.DisplayTitle, transformerType.FullName);

                        }
                        consumerWebPart.SetConnectErrorMessage(errorMessage);
                    }
                    else {
                        string errorMessage;
                        if (_webPartManager.Context != null && _webPartManager.Context.IsCustomErrorEnabled) {
                            errorMessage = SR.GetString(SR.WebPartConnection_IncompatibleConsumerTransformer,
                                consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle);
                        }
                        else {
                            errorMessage = SR.GetString(SR.WebPartConnection_IncompatibleConsumerTransformerWithType,
                                transformerType.FullName, consumerConnectionPoint.DisplayName, consumerWebPart.DisplayTitle);
                        }
                        consumerWebPart.SetConnectErrorMessage(errorMessage);
                    }
                }
            }
        }

        internal bool ConflictsWith(WebPartConnection otherConnection) {
            return (ConflictsWithConsumer(otherConnection) || ConflictsWithProvider(otherConnection));
        }

        internal bool ConflictsWithConsumer(WebPartConnection otherConnection) {
            return (!ConsumerConnectionPoint.AllowsMultipleConnections &&
                    Consumer == otherConnection.Consumer &&
                    ConsumerConnectionPoint == otherConnection.ConsumerConnectionPoint);
        }

        internal bool ConflictsWithProvider(WebPartConnection otherConnection) {
            return (!ProviderConnectionPoint.AllowsMultipleConnections &&
                    Provider == otherConnection.Provider &&
                    ProviderConnectionPoint == otherConnection.ProviderConnectionPoint);
        }

        internal void SetIsShared(bool isShared) {
            _isShared = isShared;
        }

        internal void SetIsStatic(bool isStatic) {
            _isStatic = isStatic;
        }

        internal void SetTransformer(WebPartTransformer transformer) {
            if (Transformers.Count == 0) {
                Transformers.Add(transformer);
            }
            else {
                Transformers[0] = transformer;
            }
        }

        internal void SetWebPartManager(WebPartManager webPartManager) {
            _webPartManager = webPartManager;
        }

        // Return the short typename, to improve the look of the collection editor in the designer
        public override string ToString () {
            return GetType().Name;
        }
    }
}