using System;
using System.Diagnostics;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Ninject;
using Ninject.Modules;

namespace CalculatorApp.Tests
{
    class CalculatorConfig : NinjectModule
    {
        public override void Load()
        {
            Bind<BaseCalculator>().To<CalculatorAgent>();
        }
    }

    class TestHelper<T> : IDisposable
    {
        private Random random;
        private IKernel kernel;
        private T agent;

        public T Agent
        {
            get
            {
                return agent;
            }
        }

        public TestHelper()
        {
            random = new Random();
            kernel = new StandardKernel(new CalculatorConfig());
            agent = kernel.Get<T>();
        }

        internal Tuple<int, int> GenerateValues()
        {
            return new Tuple<int, int>
            (
                item1: GenerateRandomInteger(),
                item2: GenerateRandomInteger()
            );
        }

        internal int GenerateRandomInteger()
        {
            return random.Next(0, Byte.MaxValue);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                random = null;
                kernel = null;

                var disposable = agent as IDisposable;

                if (disposable != null)
                    disposable.Dispose();
            }
        }
    }

    [TestClass()]
    public class CalculatorTests : IDisposable
    {
        private TestHelper<CalculatorAgent> helper = new TestHelper<CalculatorAgent>();

        [TestMethod()]
        public void AddRandomValues()
        {
            // Arrange
            var values = helper.GenerateValues();

            // Act
            var testResult = values.Item1 + values.Item2;
            Debug.WriteLine(String.Format("Addition result: {0}", testResult));

            // Assert
            Assert.AreEqual(testResult, helper.Agent.Add(values.Item1, values.Item2));
        }

        [TestMethod()]
        public void SubtractRandomValues()
        {
            // Arrange
            var values = helper.GenerateValues();

            // Act
            var testResult = values.Item1 - values.Item2;
            Debug.WriteLine(String.Format("Subtraction result: {0}", testResult));

            // Assert
            Assert.AreEqual(testResult, helper.Agent.Subtract(values.Item1, values.Item2));
        }

        [TestMethod()]
        public void MultiplyRandomValues()
        {
            // Arrange
            var values = helper.GenerateValues();

            // Act
            var testResult = values.Item1 * values.Item2;
            Debug.WriteLine(String.Format("Multiplication result: {0}", testResult));

            // Assert
            Assert.AreEqual(testResult, helper.Agent.Multiply(values.Item1, values.Item2));
        }

        [TestMethod()]
        public void DivideRandomValues()
        {
            // Arrange
            var values = helper.GenerateValues();

            // Act
            var testResult = values.Item1 / values.Item2;
            Debug.WriteLine(String.Format("Division result: {0}", testResult));

            // Assert
            Assert.AreEqual(testResult, helper.Agent.Divide(values.Item1, values.Item2));
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                helper.Dispose();
            }
        }
    }
}