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

namespace Chernobyl.Reflection.Template.CodeDom
{
    /// <summary>
    /// An <see cref="IMember"/> that can take any <see cref="IMember"/>
    /// instance and generate CodeDom for it.
    /// </summary>
    public abstract class CodeDomMember : MemberDecorator
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CodeDomMember"/> 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 CodeDomMember(IMember member) : base(false)
        {
            DecoratingEventCollection<CodeExpression> argumentExpressions = new DecoratingEventCollection<CodeExpression>(new List<CodeExpression>());
            argumentExpressions.ItemsAdded += ArgumentExpressionAdded;
            argumentExpressions.ItemsRemoved += ArgumentExpressionRemoved;
            ArgumentExpressions = argumentExpressions;

            // set and configure the implementer
            _memberImplementer = member;
            ConfigureImplementer();
        }

        /// <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;

                    // ensure our base class believes this is actually our new parent
                    // before attempting to do anything
                    if (base.Parent == value && base.Parent != null)
                    {
                        CodeDomInstance parentInstance = base.Parent as CodeDomInstance;

                        if (parentInstance != null)
                        {
                            // create and add the declaration of the member's class
                            parentInstance.TypeDeclaration.Members.Add(TypeDeclaration);

                            // add a field and property that will hold an instance of the member's class
                            string fieldAndPropertyBaseName = TypeDeclaration.Name + "_Instance";
                            CodeMemberField field = new CodeMemberField(TypeDeclaration.Name, "_" + fieldAndPropertyBaseName);
                            CodeFieldReferenceExpression fieldReference = new CodeFieldReferenceExpression(parentInstance.ThisReference, field.Name);
                            parentInstance.TypeDeclaration.Members.Add(field);
                            CodeMemberProperty property = new CodeMemberProperty();
                            property.Name = fieldAndPropertyBaseName;
                            property.Type = new CodeTypeReference(TypeDeclaration.Name);
                            property.HasGet = true;
                            property.HasSet = true;
                            property.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
                            property.SetStatements.Add(new CodeAssignStatement(fieldReference, new CodePropertySetValueReferenceExpression()));
                            parentInstance.TypeDeclaration.Members.Add(property);

                            // create a reference to the member's class instance property
                            CodePropertyReferenceExpression memberClassProperty = new CodePropertyReferenceExpression(parentInstance.ThisReference, property.Name);

                            // create the creation of the member's class in the constructor of the instance's class
                            CodeExpression[] memberClassArguments = new[] { new CodeVariableReferenceExpression("services"), parentInstance.ThisReference };
                            CodeAssignStatement memberClassPropertyAssignment = new CodeAssignStatement(memberClassProperty, new CodeObjectCreateExpression(TypeDeclaration.Name, memberClassArguments));
                            parentInstance.ClassConstructor.Statements.Add(memberClassPropertyAssignment);

                            // create the expression that adds the member's class instance to the ComponentChildren 
                            // property of the instance's class
                            CodeMethodInvokeExpression memberClassInstanceAddToComponents = new CodeMethodInvokeExpression(parentInstance.ComponentChildrenReference, "Add", memberClassProperty);
                            parentInstance.ClassConstructor.Statements.Add(memberClassInstanceAddToComponents);
                        }
                    }   
                }
            }
        }

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

                    // derive from the Member base class and add our constructor
                    _typeDeclaration.BaseTypes.Add(typeof(Member));
                    _typeDeclaration.Members.Add(ClassConstructor);
                }
                return _typeDeclaration;
            }
        }

        /// <summary>
        /// The constructor of the type specified by
        /// <see cref="TypeDeclaration"/> which initializes the
        /// <see cref="IMember"/>.
        /// </summary>
        public CodeConstructor ClassConstructor
        {
            get
            {
                if(_classConstructor == null)
                {
                    _classConstructor = new CodeConstructor { Attributes = MemberAttributes.Public };

                    // create the parameters of the constructor
                    CodeParameterDeclarationExpression firstParameter = new CodeParameterDeclarationExpression(typeof (IEventCollection<object>), "services");
                    _classConstructor.Parameters.Add(firstParameter);
                    CodeParameterDeclarationExpression secondParameter = new CodeParameterDeclarationExpression(typeof(Instance<>).MakeGenericType(Instance.Type), "instance");
                    _classConstructor.Parameters.Add(secondParameter);

                    // add a call to the base constructor with the appropriate arguments
                    _classConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(firstParameter.Name));
                    _classConstructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(Name));
                    _classConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(secondParameter.Name));
                }
                return _classConstructor;
            }
        }

        /// <summary>
        /// The code that generates the field for the initialization 
        /// <see cref="CountdownSwitch"/>. This member is used to invoke the 
        /// <see cref="InitializeMethod"/> when the children instances have 
        /// been initialized.
        /// </summary>
        public CodeMemberField InitializationCounterField
        {
            get
            {
                if (_initializationCounterField == null)
                {
                    _initializationCounterField = new CodeMemberField(typeof(CountdownSwitch), "_initializationCounter");
                    _typeDeclaration.Members.Add(_initializationCounterField);
                }
                    
                return _initializationCounterField;
            }
        }

        /// <summary>
        /// The code that generates a reference to the field created by
        /// <see cref="InitializationCounterField"/>.
        /// </summary>
        public CodeFieldReferenceExpression InitializationCounterFieldReference
        {
            get
            {
                if(_initializationCounterFieldReference == null)
                {
                    _initializationCounterFieldReference = new CodeFieldReferenceExpression(ThisReference, InitializationCounterField.Name);
                    
                    // Create the counter field creation statement so that it 
                    // will get added to the class constructor statement list.
                    // If we did not do this, the CountdownSwitch field in the
                    // generated code might get used before it was created which 
                    // would obviously create a crash.
                    CreateCounterFieldCreationStatement();
                }
                    
                return _initializationCounterFieldReference;
            }
        }

        /// <summary>
        /// The code the creates the <see cref="InitializationCounterField"/>.
        /// </summary>
        public CodeObjectCreateExpression InitializationCounterFieldCreation
        {
            get
            {
                CreateCounterFieldCreationStatement();
                    
                return _initializationCounterFieldCreation;
            }
        }

        /// <summary>
        /// Creates the <see cref="_initializationCounterFieldCreation"/> 
        /// statement and adds it to the <see cref="CodeMemberMethod .Statements"/>
        /// list of the <see cref="_classConstructor"/>.
        /// 
        /// </summary>
        void CreateCounterFieldCreationStatement()
        {
            if (_initializationCounterFieldCreation == null)
            {
                // create the initialization counter field creation statement
                _initializationCounterFieldCreation = new CodeObjectCreateExpression();
                _initializationCounterFieldCreation.CreateType = new CodeTypeReference(typeof(CountdownSwitch));
                _classConstructor.Statements.Add(new CodeAssignStatement(InitializationCounterFieldReference,
                                                                         _initializationCounterFieldCreation));

                // assign the initialization method to the initialization
                // CountdownSwitch's ISwitch.SwitchedOn event
                CodeAttachEventStatement initializationCounterEventAttach = new CodeAttachEventStatement(InitializationCounterFieldReference, "SwitchedOn", new CodeMethodReferenceExpression(ThisReference, InitializeMethodName));
                _classConstructor.Statements.Add(initializationCounterEventAttach);
            }   
        }

        /// <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="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 virtual CodeMemberMethod InitializeMethod
        {
            get
            {
                if(_initializeMethod == null)
                    _initializeMethod = ClassConstructor;
                
                return _initializeMethod;
            }
            set
            {
                if(_initializeMethod != value)
                {
                    CodeMemberMethod previousMethod = _initializeMethod;
                    _initializeMethod = value;

                    // We don't want to copy over all of the statements from the
                    // constructor since it contains some statements we do not want
                    // in the initialization method.
                    if (previousMethod != null && previousMethod != ClassConstructor)
                    {
                        // move the statements from the previous method to the new one
                        foreach (CodeStatement codeStatement in previousMethod.Statements)
                            _initializeMethod.Statements.Add(codeStatement);
                    }
                }
            }
        }

        /// <summary>
        /// The reference to the property
        /// <see cref="Template.Instance{TInstance}.TheGenericInstance"/> of the
        /// <see cref="Member.Instance"/> property.
        /// </summary>
        /// <exception cref="Exception">Thrown if the <see cref="Parent"/>
        /// property is not set.</exception>
        public CodeExpression TheGenericInstancePropertyReference
        {
            get
            {
                if(_theGenericInstancePropertyReference == null)
                {
                    if(Parent == null)
                        throw new Exception("This property requires that the " + 
                        "Parent property be set.");

                    // Create the reference to the "instance" constructor 
                    // variable or "IMember.Instance" property depending on the
                    // context.
                    CodeExpression instanceReferenceExpression;
                    if(InitializeMethod == ClassConstructor)
                    {
                        // The method that invokes this member is the constructor
                        // so we can just us the "instance" variable to avoid
                        // casting.
                        instanceReferenceExpression = new CodeVariableReferenceExpression("instance");
                    }
                    else
                    {
                        // We are not in the constructor so we have to grab the
                        // "Instance" property and cast it as appropriate.
                        CodePropertyReferenceExpression parentInstance = new CodePropertyReferenceExpression(ThisReference, "Instance");
                        instanceReferenceExpression = new CodeCastExpression(typeof(Instance<>).MakeGenericType(Instance.Type), parentInstance);
                    }

                    _theGenericInstancePropertyReference = new CodePropertyReferenceExpression(instanceReferenceExpression, "TheGenericInstance");
                }

                return _theGenericInstancePropertyReference;
            }
        }

        /// <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 <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 an <see cref="IEventCollection{T}"/> by the name of "services".
        /// </summary>
        public CodeExpression ServicesReference
        {
            get
            {
                return _servicesReference ?? (_servicesReference = new CodeVariableReferenceExpression("services"));
            }
        }

        /// <summary>
        /// An <see cref="ICollection{T}"/> of <see cref="CodeExpression"/>s that
        /// represent the arguments passed to the member.
        /// </summary>
        public ICollection<CodeExpression> ArgumentExpressions { get; private set; }

        /// <summary>
        /// An event handler that is invoked right after an argument 
        /// <see cref="CodeExpression"/>s are added to the 
        /// <see cref="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 virtual void ArgumentExpressionAdded(object sender, ItemsEventArgs<CodeExpression> e)
        {
            ResetInitializationCounterAmount();
        }

        /// <summary>
        /// An event handler that is invoked right after an argument 
        /// <see cref="CodeExpression"/>s are removed from the 
        /// <see cref="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 virtual void ArgumentExpressionRemoved(object sender, ItemsEventArgs<CodeExpression> e)
        {
            ResetInitializationCounterAmount();
        }        

        /// <summary>
        /// The <see cref="IMember"/> instance that implements the
        /// functionality of this class.
        /// </summary>
        protected override IMember MemberImplementer
        {
            get { return _memberImplementer; }
        }

        /// <summary>
        /// Resets the value of the <see cref="CountdownSwitch"/> with the latest
        /// <see cref="ICollection{T}.Count"/> from <see cref="ArgumentExpressions"/>.
        /// </summary>
        void ResetInitializationCounterAmount()
        {
            // We need to only count instances that aren't using CodeSnippetExpression.
            // If they are, then they are primitive instances (like "Hello World!" or 3.14)
            // and do not generate an entire class for themselves so we can't 
            // rely on their IInstance.BecameReady event to be fired.
            int count = ArgumentExpressions.Where(codeExpression => !(codeExpression is CodeSnippetExpression)).Count();
            if (count != 0)
            {
                CodePrimitiveExpression parameter = new CodePrimitiveExpression(count);
                if (InitializationCounterFieldCreation.Parameters.Count == 0)
                    InitializationCounterFieldCreation.Parameters.Add(parameter);
                else
                    InitializationCounterFieldCreation.Parameters[0] = parameter;

                // Create the initialization method.
                if (_initializeMethod == null || _initializeMethod.Name != InitializeMethodName)
                {
                    InitializeMethod = new CodeMemberMethod();
                    InitializeMethod.Name = InitializeMethodName;
                    InitializeMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
                    InitializeMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(EventArgs), "e"));
                    _typeDeclaration.Members.Add(InitializeMethod);
                }
            }
        }

        /// <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="InitializationCounterField"/>.
        /// </summary>
        CodeMemberField _initializationCounterField;

        /// <summary>
        /// The backing field to <see cref="InitializationCounterFieldReference"/>.
        /// </summary>
        CodeFieldReferenceExpression _initializationCounterFieldReference;

        /// <summary>
        /// The backing field to <see cref="InitializationCounterFieldCreation"/>.
        /// </summary>
        CodeObjectCreateExpression _initializationCounterFieldCreation;

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

        /// <summary>
        /// The name of the <see cref="InitializeMethod"/> if it is not the 
        /// constructor.
        /// </summary>
        const string InitializeMethodName = "InitializeMethod";

        /// <summary>
        /// The backing field to <see cref="TheGenericInstancePropertyReference"/>.
        /// </summary>
        CodePropertyReferenceExpression _theGenericInstancePropertyReference;

        /// <summary>
        /// The backing field to <see cref="MemberImplementer"/>.
        /// </summary>
        IMember _memberImplementer;

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

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

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