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

namespace Chernobyl.Reflection.Template.CodeDom
{
    /// <summary>
    /// An <see cref="IMember"/> that can take any <see cref="IMember"/>
    /// instance that represents a property and generate CodeDom for it.
    /// </summary>
    public abstract class CodeDomAssignableMember : CodeDomMember
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CodeDomAssignableMember"/> 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>
        protected CodeDomAssignableMember(IMember member)
            : base(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)
                        Configure();
                }
            }
        }

        /// <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 (MemberSetStatement != null || e.Items.Length > 1)
                throw new Exception("Unable to add new argument expression. This member only supports one argument.");

            _argument = e.Items.First();
            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(MemberSetStatement);
            MemberSetStatement = null;
            _argument = null;

            base.ArgumentExpressionRemoved(sender, e);
        }

        /// <summary>
        /// Initializes the <see cref="MemberSetStatement"/>. Note to
        /// implementers: Base classes should invoke the base class 
        /// <see cref="Configure()"/> method when their 
        /// <see cref="AssignableMemberReference"/> is initialized.
        /// </summary>
        protected virtual void Configure()
        {
            if(MemberSetStatement == null)
            {
                MemberSetStatement = new CodeAssignStatement();
                InitializeMethod.Statements.Add(MemberSetStatement);
            }

            if (MemberSetStatement.Left == null && AssignableMemberReference != null)
                MemberSetStatement.Left = AssignableMemberReference;

            if (MemberSetStatement.Right == null && _argument != null)
            {
                MemberSetStatement.Right = _argument;
                
                // we don't need the argument variable anymore
                _argument = null;
            }
        }

        /// <summary>
        /// The reference to the assignable member as a code expression or null
        /// if it has not yet been set up. This reference will be used to 
        /// generate code that can set the member.
        /// </summary>
        public abstract CodeExpression AssignableMemberReference { get; }

        /// <summary>
        /// The <see cref="CodeStatement"/> that represents the setting of the 
        /// member or null if this <see cref="CodeStatement"/> hasn't been
        /// created yet because an argument hasn't been added.
        /// </summary>
        CodeAssignStatement MemberSetStatement { get; set; }

        /// <summary>
        /// The <see cref="CodeExpression"/> that represents the argument that
        /// is set on this member or null if the argument has not been added, 
        /// it was removed, or it was finally set onto the
        /// <see cref="MemberSetStatement"/>'s 
        /// <see cref="CodeAssignStatement.Right"/> property.
        /// </summary>
        CodeExpression _argument;
    }
}