using System;
using System.CodeDom;
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 a method and generate CodeDom for it.
    /// </summary>
    public class CodeDomMethod : CodeDomMember
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CodeDomMethod"/> 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 method. In other words, the <see cref="MemberInfo.MemberType"/>
        /// on the <see cref="IMember.Info"/> is not equal to
        /// <see cref="MemberTypes.Method"/>.</exception>
        public CodeDomMethod(IMember member) : base(member)
        {
            if (Info.MemberType != MemberTypes.Method)
                throw new ArgumentException("The member must be a method.", "member");
        }

        /// <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)
                        ConfigureMethodInvokeExpression();
                }
            }
        }

        /// <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)
        {
            bool statementCreated = MethodInvokeStatement != null;

            // perform some error checking to make sure the user isn't trying
            // to add more arguments than is allowed
            MethodBase methodInfo = Info as MethodBase;
            if (methodInfo != null)
            {
                if (methodInfo.GetParameters().Length == 0)
                    throw new Exception("Unable to add the argument(s) to the method \"" +
                        Name + "\" on the instance \"" + Instance.Name + "\". No " + 
                        "arguments are allowed.");

                int currentArgumentCount = statementCreated == false ? 0 : MethodInvokeExpression.Parameters.Count;
                int attemptedArgumentCount = currentArgumentCount + e.Items.Length;

                if (methodInfo.GetParameters().Length < attemptedArgumentCount)
                    throw new Exception("Unable to add the argument(s) to the method \"" +
                        Name + "\" on the instance \"" + Instance.Name + "\". Only " + 
                        methodInfo.GetParameters().Length + " arguments are allowed. " +
                        "You've attempted to add " + attemptedArgumentCount);
            }
            
            // create the expression and statement if it already hasn't been created
            if (statementCreated == false)
            {
                MethodInvokeExpression = new CodeMethodInvokeExpression();
                MethodInvokeStatement = new CodeExpressionStatement(MethodInvokeExpression);
                InitializeMethod.Statements.Add(MethodInvokeStatement);
                ConfigureMethodInvokeExpression();
            }

            MethodInvokeExpression.Parameters.AddRange(e.Items);

            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)
        {
            foreach (CodeExpression codeExpression in e.Items)
                MethodInvokeExpression.Parameters.Remove(codeExpression);

            if (MethodInvokeExpression.Parameters.Count == 0)
            {
                ClassConstructor.Statements.Remove(MethodInvokeStatement);
                MethodInvokeExpression = null;
                MethodInvokeStatement = null;
            }

            base.ArgumentExpressionRemoved(sender, e);
        }

        /// <summary>
        /// Sets up the <see cref="MethodInvokeExpression"/>. This method
        /// requires that the parent has been set before it is invoked 
        /// and that the parent is of type <see cref="CodeDomInstance"/>.
        /// </summary>
        void ConfigureMethodInvokeExpression()
        {
            // note that we don't configure the AssignmentStatement if our  
            // Parent is not set to a CodeDomInstance because the property 
            // TheGenericInstancePropertyReference uses the CodeDomInstance 
            // Parent reference to generate the required code. 
            if (MethodInvokeExpression.Method.TargetObject == null &&
                Parent != null && Parent is CodeDomInstance)
            {
                MethodInvokeExpression.Method.TargetObject = TheGenericInstancePropertyReference;
                MethodInvokeExpression.Method.MethodName = Name;
            }
        }

        /// <summary>
        /// The <see cref="CodeExpression"/> that represents the invocation of
        /// this method in CodeDom.
        /// </summary>
        CodeMethodInvokeExpression MethodInvokeExpression { get; set; }

        /// <summary>
        /// <see cref="MethodInvokeExpression"/>'s representation as a
        /// <see cref="CodeStatement"/>. 
        /// </summary>
        CodeExpressionStatement MethodInvokeStatement { get; set; }
    }
}