using System;
using System.CodeDom;
using System.Linq;
using System.Reflection;
using Chernobyl.Event;

namespace Chernobyl.Reflection.Template.CodeDom
{
    /// <summary>
    /// An <see cref="IMember"/> that can take any <see cref="IMember"/>
    /// instance that represents an event and generate CodeDom for it.
    /// </summary>
    public class CodeDomEvent : CodeDomMember
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CodeDomEvent"/> class.
        /// </summary>
        /// <param name="member">The <see cref="IMember"/> instance to
        /// generate CodeDom for and provide the <see cref="IMember"/>
        /// implementation for this class.</param>
        /// <exception cref="ArgumentException">Thrown if the member is not
        /// a event. In other words, the <see cref="MemberInfo.MemberType"/>
        /// on the <see cref="IMember.Info"/> is not equal to
        /// <see cref="MemberTypes.Event"/>.</exception>
        public CodeDomEvent(IMember member) : base(member)
        {
            if (Info.MemberType != MemberTypes.Event)
                throw new ArgumentException("The member must be an event.", "member");

            AttachStatement.Event.EventName = EventName;
        }

        /// <summary>
        /// The <see cref="IComponent"/> that is the parent to this
        /// <see cref="IComponent"/>. This <see cref="IComponent"/> will be
        /// added to the parent <see cref="IComponent"/>'s
        /// <see cref="IComponent.ComponentChildren"/> list. If this
        /// <see cref="IComponent"/> is already a child to another 
        /// <see cref="IComponent"/> then it will be removed from that 
        /// <see cref="IComponent"/>'s <see cref="IComponent.ComponentChildren"/>
        /// list. Setting null on this property will cause this 
        /// <see cref="IComponent"/> to be removed from it's parent, if necessary.
        /// </summary>
        public override IComponent Parent
        {
            get { return base.Parent; }
            set
            {
                if (base.Parent != value)
                {
                    base.Parent = value;
                    if (base.Parent == value)
                        Configure();
                }
            }
        }

        /// <summary>
        /// The qualifier that exists in front of the name of an event members
        /// 'add' method. For example, if an event was named "SomeEvent", then
        /// the add method for that event would be "add_SomeEvent".
        /// </summary>
        public const string AddNameQualifier = "add_";

        /// <summary>
        /// The qualifier that exists in front of the name of an event members
        /// 'remove' method. For example, if an event was named "SomeEvent", 
        /// then the remove method for that event would be "remove_SomeEvent".
        /// </summary>
        public const string RemoveNameQualifier = "remove_";

        /// <summary>
        /// An event handler that is invoked right after an argument
        /// <see cref="CodeExpression"/>s are added to the
        /// <see cref="CodeDomMember.ArgumentExpressions"/> list.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{T}"/> instance
        /// containing the event data.</param>
        protected override void ArgumentExpressionAdded(object sender, ItemsEventArgs<CodeExpression> e)
        {
            if (AttachStatement.Listener != null || e.Items.Length > 1)
                throw new Exception("Unable to add new argument expression. This member only supports one argument.");

            AttachStatement.Listener = e.Items.First();
            InitializeMethod.Statements.Add(AttachStatement);
            Configure();

            base.ArgumentExpressionAdded(sender, e);
        }

        /// <summary>
        /// An event handler that is invoked right after an argument
        /// <see cref="CodeExpression"/>s are removed from the
        /// <see cref="CodeDomMember.ArgumentExpressions"/> list.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="ItemsEventArgs{T}"/> instance
        /// containing the event data.</param>
        protected override void ArgumentExpressionRemoved(object sender, ItemsEventArgs<CodeExpression> e)
        {
            InitializeMethod.Statements.Remove(AttachStatement);
            AttachStatement.Listener = null;

            base.ArgumentExpressionRemoved(sender, e);
        }

        /// <summary>
        /// The CodeDom method where the value of the member is set (in the case
        /// of a field, property, etc) or the method is invoked. By default, this
        /// is set to the <see cref="CodeDomMember.ClassConstructor"/>. Note 
        /// that, when set, this property will move the 
        /// <see cref="CodeMemberMethod.Statements"/> from the old 
        /// <see cref="InitializeMethod"/> to the newly specified one.
        /// </summary>
        public override CodeMemberMethod InitializeMethod
        {
            get { return base.InitializeMethod; }
            set
            {
                CodeMemberMethod previousInitializeMethod = InitializeMethod;
                base.InitializeMethod = value;

                // If a new InitializeMethod has been set that is not null and 
                // we've already added our AttachStatement to the old 
                // InitializeMethod then we need to move the AttachStatement to
                // the new InitializeMethod.
                
                if(base.InitializeMethod == value && value != null &&
                   previousInitializeMethod.Statements.Contains(AttachStatement) == true)
                {
                    previousInitializeMethod.Statements.Remove(AttachStatement);
                    base.InitializeMethod.Statements.Add(AttachStatement);
                }
            }
        }

        /// <summary>
        /// Initializes a portion of this <see cref="CodeDomEvent"/>. This 
        /// method is called after the parent is set so that the necessary 
        /// CodeDom instances can be retrieved from the parent 
        /// <see cref="CodeDomInstance"/>.
        /// </summary>
        void Configure()
        {
            // note that we don't configure the AttachStatement.Event.TargetObject
            // if our Parent is not set to a CodeDomInstance because the property 
            // TheGenericInstancePropertyReference uses the CodeDomInstance 
            // Parent reference to generate the required code. 
            if (Parent != null && Parent is CodeDomInstance && AttachStatement.Event.TargetObject == null)
                AttachStatement.Event.TargetObject = TheGenericInstancePropertyReference;
                
        }

        /// <summary>
        /// The name of the event without the "add_" or "remove_" event
        /// qualifiers.
        /// </summary>
        string EventName
        {
            get
            {
                if (_eventName == null)
                {
                    if (Name.StartsWith(AddNameQualifier) == true)
                        _eventName = Name.Remove(0, AddNameQualifier.Length);
                    else if (Name.StartsWith(RemoveNameQualifier) == true)
                        _eventName = Name.Remove(0, RemoveNameQualifier.Length);
                    else
                        _eventName = Name;
                }

                return _eventName;
            }
        }

        /// <summary>
        /// The statement that generates the event attachment code.
        /// </summary>
        public CodeAttachEventStatement AttachStatement
        {
            get
            {
                if(_attachStatement == null)
                {
                    _attachStatement = new CodeAttachEventStatement
                                           {
                                               Event = new CodeEventReferenceExpression()
                                           };
                }

                return _attachStatement;
            }
        }

        /// <summary>
        /// The backing field to <see cref="EventName"/>.
        /// </summary>
        string _eventName;

        /// <summary>
        /// The backing field to <see cref="AttachStatement"/>.
        /// </summary>
        CodeAttachEventStatement _attachStatement;
    }
}