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 an array constructor and generate CodeDom for 
    /// it.
    /// </summary>
    public class CodeDomArrayConstructor : CodeDomMember
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="CodeDomArrayConstructor"/> 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>
        public CodeDomArrayConstructor(IMember member)
            : base(member)
        {
            if (Info.MemberType != MemberTypes.Constructor)
                throw new ArgumentException("The member must be a constructor.", "member");   
        }

        /// <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 = CreateExpression != null;

            // create the expression and statement if it already hasn't been created
            if (statementCreated == false)
            {
                CreateExpression = new CodeArrayCreateExpression(Instance.Type);
                ConfigureAssignmentStatement();
            }

            CreateExpression.Initializers.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)
                CreateExpression.Initializers.Remove(codeExpression);

            if (CreateExpression.Initializers.Count == 0)
            {
                if (AssignmentStatement != null)
                {
                    InitializeMethod.Statements.Remove(AssignmentStatement);
                    AssignmentStatement = null;
                }

                CreateExpression = null;
            }

            base.ArgumentExpressionRemoved(sender, e);
        }

        /// <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)
                    {
                        // CodeDomInstance automatically add a creation statement
                        // to their constructors. We are now this instance's
                        // constructor so have the default constructor removed.
                        CodeDomInstance codeDomParent = base.Parent as CodeDomInstance;
                        if (codeDomParent != null && codeDomParent.CreationStatement != null)
                            codeDomParent.ClassConstructor.Statements.Remove(codeDomParent.CreationStatement);

                        ConfigureAssignmentStatement();
                    }

                }
            }
        }

        /// <summary>
        /// Creates and sets up the <see cref="AssignmentStatement"/>. 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 ConfigureAssignmentStatement()
        {
            // 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 (CreateExpression != null && AssignmentStatement == null &&
                Parent != null && Parent is CodeDomInstance)
            {
                AssignmentStatement = new CodeAssignStatement(TheGenericInstancePropertyReference, CreateExpression);
                InitializeMethod.Statements.Add(AssignmentStatement);
            }
        }

        /// <summary>
        /// The <see cref="CodeExpression"/> that represents the creation of the
        /// array using the constructor.
        /// </summary>
        CodeArrayCreateExpression CreateExpression { get; set; }

        /// <summary>
        /// The <see cref="CodeStatement"/> that represents the assignment of the
        /// instance in CodeDom.
        /// </summary>
        CodeAssignStatement AssignmentStatement { get; set; }
    }
}