using System;
using System.Linq;
using System.Utility;
using Chernobyl.Attribution;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Reflection;
using Chernobyl.Values;
using NUnit.Framework;

namespace Chernobyl.Dependency
{
    public abstract class GetAttributeTests
    {
        [Test, Description("ParameterException is thrown when more than one " +
                           "IStorageAttribute is specified on a parameter.")]
        public virtual void ParameterExceptionWhenMultipleIStorageAttributeOnParameter()
        {
            Assert.Throws<ParameterException>(() => GetFirstParameter(MultiStorageMethod));
        }

        [Test, Description("ParameterException is thrown when no IKeyAttributes is " +
                           "specified on a parameter.")]
        public virtual void ParameterExceptionWhenNoIKeyAttributeOnParameter()
        {
            Assert.Throws<ParameterException>(() => GetFirstParameter(NoKeyMethod));
        }

        [Test, Description("ParameterException is thrown when more than one " +
                           "IKeyAttributes is specified on a parameter.")]
        public virtual void ParameterExceptionWhenMoreThanOneIKeyAttributeOnParameter()
        {
            Assert.Throws<ParameterException>(() => GetFirstParameter(MultiKeyMethod));
        }

        [Test, Description("Parameter is received when immediately provided.")]
        public virtual void ParameterProvidedImmediately()
        {
            const string expected = "Bob";
            var expectedValue = new BasicContainer<object>(expected);

            StaticStorageAttribute.Default.Container.Remove(FirstNameId);
            StaticStorageAttribute.Default.Container.Add(FirstNameId, expectedValue);

            var value = GetFirstParameter(SingleParameterMethod);
            value.Request((sender, args) =>
            {
                args.NewValue.Require<string>().IsEqualTo(expected, "first parameter");
                Assert.Pass();
            });

            Assert.Fail("Value was not received");
        }

        [Test, Description("Parameter is received when late provided.")]
        public virtual void ParameterProvidedLate()
        {
            const string expected = "Bob";
            var expectedValue = new DynamicContainer<object>();

            StaticStorageAttribute.Default.Container.Remove(FirstNameId);
            StaticStorageAttribute.Default.Container.Add(FirstNameId, expectedValue.NotNull());

            var value = GetFirstParameter(SingleParameterMethod);

            var valueSet = new DynamicContainer<bool>(false);
            value.Request((sender, args) =>
            {
                args.NewValue.Require<string>().IsEqualTo(expected, "first parameter");
                Assert.True(valueSet.Value, "Value should not have been received yet.");
                Assert.Pass();
            });

            valueSet.Value = true;
            expectedValue.Value = expected;

            Assert.Fail("Value was not retrieved");
        }

        #region Utilty

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

        public void MultiStorage([Get, StaticStorage, StorageAttribute, Guid(SetAttributeTests.Ids.Hello)]string param) { }

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

        public void NoKey([Get]string param) { }

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

        public void MultiKey([Get, Guid(SetAttributeTests.Ids.FirstName), Guid(SetAttributeTests.Ids.Hello)]string param) { }

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

        public void SingleParameter([Get, Guid(SetAttributeTests.Ids.FirstName)] string param) {}

        /// <summary>
        /// Utility method to help with testing. Creates the tested instance
        /// using <see cref="CreateGetAttribute()"/> and then uses it and the
        /// specified method to get the parameter value.
        /// </summary>
        /// <param name="method">The name of the method whose first parameter is
        /// to be retrieved.</param>
        /// <returns>The parameter requested.</returns>
        IValue<Object> GetFirstParameter(string method)
        {
            var get = CreateGetAttribute();
            var methodInfo = GetType().GetMethod(method);
            return get.Get(methodInfo.GetParameters().First());
        }

        /// <summary>
        /// A <see cref="IStorageAttribute{TKey, TValue}"/> used for testing
        /// purposes.
        /// </summary>
        public class StorageAttribute : Attribute, IStorageAttribute<Object, IValue<Object>>
        {
            /// <summary>
            /// The container the instance(s) are to be stored.
            /// </summary>
            public IEventDictionary<Object, IValue<Object>> Container
            {
                get { return StaticContainer; }
            }

            /// <summary>
            /// The backing field to <see cref="Container"/>.
            /// </summary>
            static readonly IEventDictionary<Object, IValue<Object>> StaticContainer =
                new DecoratingEventDictionary<Object, IValue<Object>>();
        }

        static readonly Guid FirstNameId = new Guid(SetAttributeTests.Ids.FirstName);

        #endregion

        #region Overridables

        /// <summary>
        /// Returns the <see cref="IGetAttribute"/> instance to be tested.
        /// </summary>
        /// <returns>The instance to be tested.</returns>
        public abstract IGetAttribute CreateGetAttribute();

        #endregion
    }
}