using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Utility;
using Chernobyl.Dependency;
using Chernobyl.Reflection;
using Chernobyl.Values;
using NUnit.Framework;

namespace Chernobyl.Attribution
{
    [TestFixture, Description("Tests for the RunAttribute type.")]
    public class RunAttributeTests
    {
        ///////////////////////////////////////////////////////////////////////
        #region Exception Tests
        ///////////////////////////////////////////////////////////////////////

        [Test, Description("MethodException thrown if non-static method is attributed.")]
        public virtual void MethodExceptionWhenNonStaticMethodAttributed()
        {
            Assert.Throws<MethodException>(() => ProcessMethod(Methods.AttributedNonStaticName));
        }

        #endregion

        ///////////////////////////////////////////////////////////////////////
        #region IgnoreReturnValue Tests
        ///////////////////////////////////////////////////////////////////////

        [Test, Description("MethodException when method has return value and " +
                           "IgnoreReturnValue is false.")]
        public virtual void MethodExceptionWithReturnValueAndFalseIgnoreReturnValue()
        {
            Assert.Throws<MethodException>(() => ProcessMethod(Methods.FalseIgnoreReturnValueName));
        }

        [Test, Description("No MethodException when method has return value and " +
                           "IgnoreReturnValue is true.")]
        public virtual void NoMethodExceptionWithReturnValueAndTrueIgnoreReturnValue()
        {
            ProcessMethod(Methods.TrueIgnoreReturnValueName);
        }

        #endregion

        ///////////////////////////////////////////////////////////////////////
        #region Static Method Run Tests
        ///////////////////////////////////////////////////////////////////////

        [Test, Description("Static method with NO dependencies is run.")]
        public virtual void NoDependenciesStaticMethodRun()
        {
            // Create the attributed type and process it.
            try
            {
                ProcessMethod(Methods.AttributedTypeWithNoDependenciesName);
            }
            catch (TargetInvocationException e)
            {
                // The "pass" exception will be wrapped in a TargetInvocationException
                // since we are using reflection
                throw e.InnerException;
            }

            Assert.Fail("Method should have been run and caused this test to pass.");
        }

        [Test, Description("Static method with dependencies is run.")]
        public virtual void DependenciesStaticMethodRun()
        {
            // Clear the container to prevent shared state screwing up the tests.
            // Processing the type will leave the instance stored in the default
            // instance of the StaticStorageAttribute.
            var container = StaticStorageAttribute.Default.Container;
            container.Clear();

            // Add the dependencies to be given to the static method.
            container.Add(new Guid(SetAttributeTests.Ids.FirstName),
                          new BasicContainer<object>(SetAttributeTests.Returns.FirstName));
            container.Add(new Guid(SetAttributeTests.Ids.LastName),
                          new BasicContainer<object>(SetAttributeTests.Returns.LastName));

            // Create the attributed type and process it.
            try
            {
                ProcessMethod(Methods.AttributedTypeWithDependenciesName);
            }
            catch (TargetInvocationException e)
            {
                // The "pass" exception will be wrapped in a TargetInvocationException
                // since we are using reflection
                throw e.InnerException;
            }

            Assert.Fail("Method should have been run and caused this test to pass.");
        }

        #endregion

        ///////////////////////////////////////////////////////////////////////
        #region Utilities
        ///////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Retrieves the method named by <paramref name="methodName"/> from the,
        /// type returned by <see cref="CreateAttributedMethods()"/> grabs the
        /// first <see cref="RunAttribute"/> from it, and executes
        /// <see cref="RunAttribute.Process(MethodInfo)"/> on it.
        /// </summary>
        /// <param name="methodName">The name of the attributed method.</param>
        public void ProcessMethod(string methodName)
        {
            var type = CreateAttributedMethods();
            var method = type.GetMethod(methodName);
            var attribute = method.GetCustomAttributes<RunAttribute>(true).First();
            attribute.Process(method);
        }

        /// <summary>
        /// Holds the <see cref="RunAttribute"/> attributed methods used for
        /// testing purposes.
        /// </summary>
        protected class Methods
        {
            /// <summary>
            /// The name of the <see cref="AttributedNonStatic()"/> method.
            /// </summary>
            public const string AttributedNonStaticName = "AttributedNonStatic";

            /// <summary>
            /// The name of the <see cref="AttributedTypeWithNoDependencies()"/> method.
            /// </summary>
            public const string AttributedTypeWithNoDependenciesName = "AttributedTypeWithNoDependencies";

            /// <summary>
            /// The name of the <see cref="AttributedTypeWithDependencies(string, string)"/> method.
            /// </summary>
            public const string AttributedTypeWithDependenciesName = "AttributedTypeWithDependencies";

            /// <summary>
            /// The name of the <see cref="FalseIgnoreReturnValue()"/> method.
            /// </summary>
            public const string FalseIgnoreReturnValueName = "FalseIgnoreReturnValue";

            /// <summary>
            /// The name of the <see cref="TrueIgnoreReturnValue()"/> method.
            /// </summary>
            public const string TrueIgnoreReturnValueName = "TrueIgnoreReturnValue";

            /// <summary>
            /// This method will invoke <see cref="Assert.Fail(string)"/> if
            /// invoked.
            /// </summary>
            [Run]
            public void AttributedNonStatic()
            {
                Assert.Fail("This method should NOT have been run.");
            }

            /// <summary>
            /// This method will invoke <see cref="Assert.Pass()"/> if
            /// invoked.
            /// </summary>
            [Run]
            public static void AttributedTypeWithNoDependencies()
            {
                Assert.Pass();
            }

            /// <summary>
            /// When invoked, this method verifies that <paramref name="firstName"/>
            /// is equal to <see cref="SetAttributeTests.Returns.FirstName"/>
            /// and <paramref name="lastName"/> is equal to
            /// <see cref="SetAttributeTests.Returns.LastName"/>, throwing
            /// exceptions if they are not. After those are verified
            /// <see cref="Assert.Pass()"/> are invoked.
            /// </summary>
            /// <param name="firstName">The same value as
            /// <see cref="SetAttributeTests.Returns.FirstName"/>.</param>
            /// <param name="lastName">The same value as
            /// <see cref="SetAttributeTests.Returns.LastName"/>.</param>
            [Run]
            public static void AttributedTypeWithDependencies([Get, Guid(SetAttributeTests.Ids.FirstName)]string firstName,
                                                              [Get, Guid(SetAttributeTests.Ids.LastName)]string lastName)
            {
                firstName.IsEqualTo(SetAttributeTests.Returns.FirstName, SetAttributeTests.Ids.FirstName);
                lastName.IsEqualTo(SetAttributeTests.Returns.LastName, SetAttributeTests.Ids.LastName);
                Assert.Pass();
            }

            /// <summary>
            /// Executing the <see cref="RunAttribute.Process(MethodInfo)"/> on
            /// this method will cause an exception to be thrown.
            /// </summary>
            [Run(IgnoreReturnValue = false)]
            public static bool FalseIgnoreReturnValue()
            {
                return false;
            }

            /// <summary>
            /// Executing the <see cref="RunAttribute.Process(MethodInfo)"/> on
            /// this method will NOT cause an exception to be thrown.
            /// </summary>
            [Run(IgnoreReturnValue = true)]
            public static bool TrueIgnoreReturnValue()
            {
                return true;
            }
        }

        #endregion

        ///////////////////////////////////////////////////////////////////////
        #region Overridables
        ///////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Creates a type containing <see cref="RunAttribute"/> attributed
        /// methods. The type returned should contain the same methods (including
        /// signature, execution, and attribution) defined by <see cref="Methods"/>.
        /// </summary>
        /// <returns>The instance containing the attributed methods to be tested.</returns>
        protected virtual Type CreateAttributedMethods()
        {
            return typeof(Methods);
        }

        #endregion
    }
}