using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Web.Mvc;
using NUnit.Framework;

namespace UnitTests.Controllers
{
    public static class ActionResultExtensions
    {
        #region Routing Assertions

        /// <summary>
        /// Assert that the action in the result's Route Data is <c ref="actionName"/>
        /// </summary>
        /// <param name="result">The ActionResult to make the assertion against.</param>
        /// <param name="actionName">The name of the Action to assert</param>
        public static void AssertAction(this ActionResult result, string actionName)
        {
            Assert.AreEqual(actionName, ((RedirectToRouteResult)result).Values["action"]);
        }

        #region AssertRoute
        /// <summary>
        /// Assert that the result's routing data matches that given in the action Expression
        /// </summary>
        /// <typeparam name="TController">Controller Type</typeparam>
        /// <param name="result">The ActionResult to make the assertion against.</param>
        /// <param name="action">Expression containing the route you'd like to assert</param>
        public static void AssertRoute<TController>(this ActionResult result, Expression<Action<TController>> action) 
            where TController : Controller
        {
            // Figure out the action name
            var actionName = ((MethodCallExpression)action.Body).Method.Name;

            // Figure out the controller name
            var controllerName = typeof(TController).Name;
            if (controllerName.EndsWith("Controller", StringComparison.OrdinalIgnoreCase))
                controllerName = controllerName.Remove(controllerName.Length - 10, 10);

            AssertRoute(result, controllerName, actionName);
        }

        /// <summary>
        /// Assert that the result's routing data matches the Action actionName 
        /// on the controller type TController
        /// </summary>
        /// <typeparam name="TController">Controller Type</typeparam>
        /// <param name="result">The ActionResult to make the assertion against.</param>
        /// <param name="actionName">Name of the action to match</param>
        public static void AssertRoute<TController>(this ActionResult result, string actionName)
            where TController : Controller
        {
            var controllerName = typeof (TController).Name;
            AssertRoute(result, controllerName, actionName);
        }
        private static void AssertRoute(this ActionResult result, string controllerName, string actionName)
        {
            var routeValues = ((RedirectToRouteResult) result).Values;
            Assert.AreEqual(controllerName, routeValues["controller"]);
            Assert.AreEqual(actionName, routeValues["action"]);
        }

        #endregion

        #endregion
        
        /// <summary>
        /// Assert that the result's View Name matches expectedViewName
        /// </summary>
        /// <param name="result">
        /// The ActionResult to make the assertion against.
        /// (Assumed to be a ViewResult)
        /// </param>
        /// <param name="expectedViewName">The name of the View to match</param>
        public static void AssertViewName(this ActionResult result, string expectedViewName)
        {
            Assert.AreEqual(expectedViewName, ((ViewResult)result).ViewName);
        }

        /// <summary>
        /// Assert that an object in the result's ViewData matches the expectedObject
        /// </summary>
        /// <param name="result">
        /// The ActionResult to make the assertion against.
        /// (Assumed to be a ViewResult)
        /// </param>
        /// <param name="expectedObject">The name of the View to match</param>
        public static void AssertViewData(this ActionResult result, object expectedObject)
        {
            AssertViewData(result, null, expectedObject);
        }
        /// <summary>
        /// Assert that an object in the result's ViewData matches the expectedObject
        /// </summary>
        /// <param name="result">
        /// The ActionResult to make the assertion against.
        /// (Assumed to be a ViewResult)
        /// </param>
        /// <param name="key">The ViewData key in which the expected ViewData to be matched is stored</param>
        /// <param name="expectedObject">The name of the View to match</param>
        public static void AssertViewData(this ActionResult result, string key, object expectedObject)
        {
            var actualViewData = ((ViewResult)result).ViewData;
            if (string.IsNullOrEmpty(key))
            {
                if (actualViewData.Model != null)
                    Assert.AreSame(expectedObject, actualViewData.Model);
                else
                    Assert.AreSame(expectedObject, actualViewData);
            }
            else
                Assert.AreSame(expectedObject, actualViewData[key]);
        }

        /// <summary>
        /// Assert that a group of objects in the result's ViewData matches those in the mappings dictionary.
        /// </summary>
        /// <param name="result">
        /// The ActionResult to make the assertion against.
        /// (Assumed to be a ViewResult)
        /// </param>
        /// <param name="mappings">
        /// A dictionary containing keys and values to be validated against the result's ViewData
        /// </param>
        public static void AssertViewDataMappings(this ActionResult result, IDictionary<string, object> mappings)
        {
            foreach (var key in mappings.Keys)
                AssertViewData(result, key, mappings[key]);
        }

    }
}