using System;
using System.CodeDom;
using System.Reflection;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Readiness;
using Chernobyl.Switch;

namespace Chernobyl.Reflection.Template.CodeDom
{
    /// <summary>
    /// An <see cref="IInstance"/> that can take any <see cref="IInstance"/>
    /// instance and generate CodeDom for it.
    /// </summary>
    public class CodeDomInstance : InstanceDecorator
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CodeDomInstance"/> class.
        /// </summary>
        /// <param name="decoratedInstance">The <see cref="IInstance"/> instance to
        /// generate CodeDom for and provide the <see cref="IInstance"/>
        /// implementation for this class.</param>
        public CodeDomInstance(IInstance decoratedInstance)
            : this(decoratedInstance, false)
        {
            ConfigureImplementer();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CodeDomInstance"/> class.
        /// </summary>
        /// <param name="decoratedInstance">The <see cref="IInstance"/> instance to
        /// generate CodeDom for and provide the <see cref="IInstance"/>
        /// implementation for this class.</param>
        /// <param name="configure">True if this instance should be configured
        /// immediately, false if the 
        /// <see cref="ComponentDecorator.ConfigureImplementer()"/> method will be 
        /// invoked at a later time by the implementing type.</param>
        protected CodeDomInstance(IInstance decoratedInstance, bool configure)
            : base(configure)
        {
            // set the _decoratedInstance and then configure that implementer
            // now that it is set.
            _decoratedInstance = decoratedInstance;
        }

        /// <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)
                {
                    IComponent previousParent = base.Parent;
                    base.Parent = value;

                    // ensure our base class believes this is actually our new 
                    // parent before attempting to do anything
                    if (base.Parent == value && base.Parent != null)
                    {
                        // Remove our changes from the previous parent.
                        CodeDomMember previousParentMember = previousParent as CodeDomMember;
                        if(previousParentMember != null)
                        {
                            previousParentMember.TypeDeclaration.Members.Remove(TypeDeclaration);
                            previousParentMember.TypeDeclaration.Members.Remove(ParentField);
                            previousParentMember.TypeDeclaration.Members.Remove(ParentProperty);

                            // Remove the creation/assignment statement of the
                            // IInstance from the previous IMember parent's 
                            // constructor.
                            previousParentMember.ClassConstructor.Statements.Remove(_memberClassPropertyAssignment);

                            // Remove the code statement that adds this IInstance
                            // to the Parent IMember's ComponentChildren collection.
                            previousParentMember.ClassConstructor.Statements.Remove(_memberClassInstanceAddToComponents);

                            // Remove the code statement that attaches the 
                            // CountdownSwitch's CountdownSwitch.Countdown(object, EventArgs) 
                            // method to the BecameReady event of the generated 
                            // IInstance
                            previousParentMember.ClassConstructor.Statements.Remove(_parentMemberInitializationCountdwonEventAttach);

                            // Remove the expression that references this IInstance
                            // as one of the arguments.
                            previousParentMember.ArgumentExpressions.Remove(_instanceReference);
                        }
                        
                        // Now make changes to the new parent.
                        CodeDomMember parentMember = base.Parent as CodeDomMember;
                        if (parentMember != null)
                        {
                            parentMember.TypeDeclaration.Members.Add(TypeDeclaration);
                            parentMember.TypeDeclaration.Members.Add(ParentField);
                            parentMember.TypeDeclaration.Members.Add(ParentProperty);

                            // create a reference from the parent member to the instance's class instance property:
                            // This code creates (in the case of an String): this.String_36193440_Instance
                            CodePropertyReferenceExpression instanceClassProperty = new CodePropertyReferenceExpression(parentMember.ThisReference, ParentProperty.Name);

                            // create the creation of the instance's class in the constructor of the member's class
                            CodeExpression[] instanceClassArguments = new[] { parentMember.ServicesReference };
                            _memberClassPropertyAssignment = new CodeAssignStatement(instanceClassProperty, new CodeObjectCreateExpression(TypeDeclaration.Name, instanceClassArguments));
                            parentMember.ClassConstructor.Statements.Add(_memberClassPropertyAssignment);

                            // create the expression that adds the instance's class instance to the ComponentChildren 
                            // property of the member's class
                            CodeMethodInvokeExpression memberClassInstanceAddToComponentsExpression = new CodeMethodInvokeExpression(parentMember.ComponentChildrenReference, "Add", instanceClassProperty);
                            _memberClassInstanceAddToComponents = new CodeExpressionStatement(memberClassInstanceAddToComponentsExpression);
                            parentMember.ClassConstructor.Statements.Add(_memberClassInstanceAddToComponents);

                            // assign the initialization CountdownSwitch's CountdownSwitch.Countdown(object, EventArgs) method
                            // to the BecameReady event of the generated IInstance. This code creates (in the parent member's
                            // constructor): [instance's name].BecameReady += this._initializationCounter.Countdown;
                            _parentMemberInitializationCountdwonEventAttach =
                                new CodeAttachEventStatement(instanceClassProperty, "BecameReady", new CodeMethodReferenceExpression(parentMember.InitializationCounterFieldReference, "Countdown"));
                            parentMember.ClassConstructor.Statements.Add(_parentMemberInitializationCountdwonEventAttach);

                            // now set (property, field) or invoke (method, constructor) the member with
                            // this instance as one or more of it's arguments
                            _instanceReference = new CodePropertyReferenceExpression(instanceClassProperty, GenericInstanceName);
                            parentMember.ArgumentExpressions.Add(_instanceReference);
                        }
                    }   
                }
            }
        }

        /// <summary>
        /// The code generated property that represents an instance of 
        /// <see cref="TypeDeclaration"/>. This field is located in the parent 
        /// members class.
        /// </summary>
        public CodeMemberProperty ParentProperty
        {
            get
            {
                if(_parentProperty == null)
                {
                    _parentProperty = new CodeMemberProperty
                    {
                        Name = ParentField.Name.TrimStart('_'),
                        Type = new CodeTypeReference(TypeDeclaration.Name),
                        HasGet = true,
                        HasSet = true
                    };

                    CodeFieldReferenceExpression fieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), ParentField.Name);
                    _parentProperty.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
                    _parentProperty.SetStatements.Add(new CodeAssignStatement(fieldReference, new CodePropertySetValueReferenceExpression()));
                }

                return _parentProperty;
            }
        }

        /// <summary>
        /// The code generated field that represents an instance of 
        /// <see cref="TypeDeclaration"/>. This field is located in the parent 
        /// members class.
        /// </summary>
        public CodeMemberField ParentField
        {
            get
            {
                if (_parentField == null)
                {
                    string fieldAndPropertyName = TypeDeclaration.Name + "_Instance";
                    _parentField = new CodeMemberField(TypeDeclaration.Name, "_" + fieldAndPropertyName);
                }

                return _parentField;
            }
        }

        /// <summary>
        /// The declaration of the type that can be used to create and initialize
        /// this <see cref="IInstance"/>.
        /// </summary>
        public virtual CodeTypeDeclaration TypeDeclaration
        {
            get
            {
                if (_typeDeclaration == null)
                {
                    _typeDeclaration = new CodeTypeDeclaration(CodeName) {TypeAttributes = TypeAttributes.NotPublic};

                    // derive from the Instance<> base class and add our constructor
                    _typeDeclaration.BaseTypes.Add(GenericInstanceTypeReference);
                    _typeDeclaration.Members.Add(ClassConstructor);
                }
                return _typeDeclaration;
            }
        }

        /// <summary>
        /// The constructor of the type specified by
        /// <see cref="TypeDeclaration"/> which initializes the
        /// <see cref="IInstance"/>.
        /// </summary>
        public virtual CodeConstructor ClassConstructor
        {
            get
            {
                if (_classConstructor == null)
                {
                    // create a constructor for this class
                    _classConstructor = new CodeConstructor
                                        { Attributes = MemberAttributes.Public };
                    _classConstructor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IEventCollection<object>), ServicesReferenceName));
                    _classConstructor.BaseConstructorArgs.Add(ServicesReference);

                    if(Name.Length != 0)
                        _classConstructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(Name));

                    // add a default constructor call for this instance, but
                    // only if this instance's type supports one.
                    if (CreationStatement != null)
                        _classConstructor.Statements.Add(CreationStatement);
                }

                return _classConstructor;
            }
        }

        /// <summary>
        /// The CodeDom method where the value of the instance is set. By
        /// default, this is set to the <see cref="ClassConstructor"/>.
        /// </summary>
        public CodeMemberMethod InitializeMethod
        {
            get
            {
                _initializeMethod = _initializeMethod ?? ClassConstructor;
                return _initializeMethod;
            }
            set { _initializeMethod = value; }
        }

        /// <summary>
        /// A <see cref="CodeStatement"/> that represents the creation of this
        /// instance. By default, this property returns the statement for the
        /// creation of the instance using a default constructor or null if this 
        /// <see cref="IInstance"/>'s <see cref="Type"/> does not contain a
        /// parameterless constructor.
        /// </summary>
        public virtual CodeStatement CreationStatement
        {
            get
            {
                if (_creationStatement == null && ContainsParameterlessConstructor == true)
                {
                    CodePropertyReferenceExpression instanceStatement = new CodePropertyReferenceExpression(ThisReference, "TheInstance");
                    CodeObjectCreateExpression createExpression = new CodeObjectCreateExpression(Type);
                    _creationStatement = new CodeAssignStatement(instanceStatement, createExpression);
                }
                return _creationStatement;
            }
        }

        /// <summary>
        /// A <see cref="CodeTypeReference"/> for the type 
        /// <see cref="Instance{T}"/> taking a the generic type parameter 
        /// represented by <see cref="Type"/>.
        /// </summary>
        public CodeTypeReference GenericInstanceTypeReference
        {
            get
            {
                if(_genericInstanceTypeReference == null)
                {
                    Type genericType = typeof (Instance<>).MakeGenericType(new[] {Type});
                    _genericInstanceTypeReference = new CodeTypeReference(genericType);
                }

                return _genericInstanceTypeReference;
            }
        }

        /// <summary>
        /// A <see cref="CodeExpression"/> that references the 
        /// <see cref="IComponent.ComponentChildren"/> property of the CodeDom
        /// class generated by this class.
        /// </summary>
        public CodeExpression ComponentChildrenReference
        {
            get
            {
                if (_componentChildrenReference == null)
                    _componentChildrenReference = new CodePropertyReferenceExpression(ThisReference, "ComponentChildren");

                return _componentChildrenReference;
            }
        }

        /// <summary>
        /// A reference to the "this". Used by children to reference the CodeDom
        /// class generated by this class.
        /// </summary>
        public CodeExpression ThisReference
        {
            get { return _thisReference ?? (_thisReference = new CodeThisReferenceExpression()); }
        }

        /// <summary>
        /// A reference to an <see cref="IEventCollection{T}"/> by the name of "services".
        /// </summary>
        public CodeExpression ServicesReference
        {
            get
            {
                return _servicesReference ?? (_servicesReference = new CodeVariableReferenceExpression(ServicesReferenceName));
            }
        }

        /// <summary>
        /// The <see cref="IInstance"/> instance that implements the
        /// functionality of this class.
        /// </summary>
        public override IInstance DecoratedInstance
        {
            get { return _decoratedInstance; }
        }

        /// <summary>
        /// The name of the <see cref="Instance{T}.TheGenericInstance"/> property.
        /// </summary>
        protected const string GenericInstanceName = "TheGenericInstance";

        /// <summary>
        /// True if this instance is of a <see cref="Type"/> that has a
        /// parameterless constructor, false if otherwise.
        /// </summary>
        bool ContainsParameterlessConstructor
        {
            get
            {
                if(_containsParameterlessConstructor.HasValue == false)
                    _containsParameterlessConstructor = Type.GetConstructor(Type.EmptyTypes) != null;

                return _containsParameterlessConstructor.Value;
            }
        }

        /// <summary>
        /// The name of an <see cref="IEventCollection{T}"/> by the name of "services"
        /// within the <see cref="IInstance"/>'s classes constructor.
        /// </summary>
        const string ServicesReferenceName = "services";

        /// <summary>
        /// The backing field to <see cref="TypeDeclaration"/>.
        /// </summary>
        CodeTypeDeclaration _typeDeclaration;

        /// <summary>
        /// The backing field to <see cref="ClassConstructor"/>.
        /// </summary>
        CodeConstructor _classConstructor;

        /// <summary>
        /// The backing field to <see cref="InitializeMethod"/>.
        /// </summary>
        CodeMemberMethod _initializeMethod;

        /// <summary>
        /// The backing field to <see cref="CreationStatement"/>.
        /// </summary>
        CodeStatement _creationStatement;

        /// <summary>
        /// The backing field to <see cref="GenericInstanceTypeReference"/>.
        /// </summary>
        CodeTypeReference _genericInstanceTypeReference;

        /// <summary>
        /// The backing field to <see cref="ComponentChildrenReference"/>.
        /// </summary>
        CodeExpression _componentChildrenReference;

        /// <summary>
        /// The backing field to <see cref="ThisReference"/>.
        /// </summary>
        CodeExpression _thisReference;

        /// <summary>
        /// The backing field to <see cref="ServicesReference"/>.
        /// </summary>
        CodeExpression _servicesReference;

        /// <summary>
        /// The backing field to <see cref="ParentField"/>
        /// </summary>
        CodeMemberField _parentField;

        /// <summary>
        /// The backing field to <see cref="_parentProperty"/>.
        /// </summary>
        CodeMemberProperty _parentProperty;

        /// <summary>
        /// The backing field to <see cref="DecoratedInstance"/>.
        /// </summary>
        IInstance _decoratedInstance;

        /// <summary>
        /// The backing field to <see cref="ContainsParameterlessConstructor"/>.
        /// If this value is null, then this <see cref="Type"/>'s containment of 
        /// a parameterless constructor hasn't been identified yet. True if it 
        /// does contain one, false if otherwise.
        /// </summary>
        bool? _containsParameterlessConstructor;

        /// <summary>
        /// The code statement that creates this <see cref="IInstance"/>'s class
        /// in the constructor of the <see cref="Parent"/> 
        /// <see cref="IMember"/>'s class.
        /// </summary>
        CodeAssignStatement _memberClassPropertyAssignment;

        /// <summary>
        /// The code statement that adds this <see cref="IInstance"/>'s class 
        /// instance to the <see cref="IComponent.ComponentChildren"/> property 
        /// of the <see cref="Parent"/> <see cref="IMember"/>'s class
        /// </summary>
        CodeExpressionStatement _memberClassInstanceAddToComponents;

        /// <summary>
        /// The code statement that attaches the initialization 
        /// <see cref="CountdownSwitch"/>'s 
        /// <see cref="CountdownSwitch.Countdown(object, EventArgs)"/> method
        /// to the <see cref="IReadyable.BecameReady"/> event of the generated 
        /// <see cref="IInstance"/>.
        /// </summary>
        CodeAttachEventStatement _parentMemberInitializationCountdwonEventAttach;

        /// <summary>
        /// The code reference to this <see cref="IInstance"/> for use as an 
        /// argument to the the parent <see cref="IMember"/>.
        /// </summary>
        CodeExpression _instanceReference;
    }
}