using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace System.Web.Mvc
{

    /// <summary>
    /// Set of extensions methods on ControllerBase class that implements template method pattern for action method body.
    /// The stages of action method execution are: view-model initialization, view-model update and action result obtaining.
    /// </summary>
    public static class TemplateMethodExtensions
    {

        #region for GET action methods

        /// <summary>
        /// Provides the right action method template for GET action method (action method that load ViewModel only).
        /// ViewModel is automatically created using parameterless constructor and assigned into ViewData.Model property.
        /// If some exception occurs during ViewModel initialization or update then this exception is added into ModelState.
        /// </summary>
        /// <typeparam name="TViewModel">ViewModel class that in used in this action method and related view.</typeparam>
        /// <param name="controller">Controller.</param>
        /// <param name="handleInvalidViewModelAfterInitialization">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel initialization.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="obtainActionResult">
        /// Delegate that returns action result that will be returned from action method. If null then null is returned.
        /// </param>
        /// <returns>Returns action result.</returns>
        /// <remarks>This method only should be called inside action method.</remarks>
        public static ActionResult ProcessGET<TViewModel>(this ControllerBase controller,
            Func<TViewModel, ActionResult> handleInvalidViewModelAfterInitialization,
            Func<TViewModel, ActionResult> obtainActionResult)
            where TViewModel : new()
        {
            return ProcessGET<TViewModel>(controller,
                () => new TViewModel(),
                handleInvalidViewModelAfterInitialization,
                obtainActionResult);
        }


        /// <summary>
        /// Provides the right action method template for GET action method (action method that load ViewModel only).
        /// If some exception occurs during ViewModel initialization or update then this exception is added into ModelState.
        /// </summary>
        /// <typeparam name="TViewModel">ViewModel class that in used in this action method and related view.</typeparam>
        /// <param name="controller">Controller.</param>
        /// <param name="initializeViewModel">
        /// Creates ViewModel instance. This would probably done using action method parameters. If null is specified then ViewModel will have its default value.
        /// After model is created then it's assigned to ViewData.Model property.
        /// </param>
        /// <param name="handleInvalidViewModelAfterInitialization">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel initialization.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="obtainActionResult">
        /// Delegate that returns action result that will be returned from action method. If null then null is returned.
        /// </param>
        /// <returns>Returns action result.</returns>
        /// <remarks>This method only should be called inside action method.</remarks>
        public static ActionResult ProcessGET<TViewModel>(this ControllerBase controller,
            Func<TViewModel> initializeViewModel, 
            Func<TViewModel, ActionResult> handleInvalidViewModelAfterInitialization,
            Func<TViewModel, ActionResult> obtainActionResult)
        {
            return ProcessGET<TViewModel>(controller,
                initializeViewModel,
                (viewModel, exception) => { controller.ViewData.ModelState.AddModelError("error", exception); return null; },
                handleInvalidViewModelAfterInitialization,
                obtainActionResult,
                null);
        }


        /// <summary>
        /// Provides the right action method template for GET action method (action method that load ViewModel only).
        /// </summary>
        /// <typeparam name="TViewModel">ViewModel class that in used in this action method and related view.</typeparam>
        /// <param name="controller">Controller.</param>
        /// <param name="initializeViewModel">
        /// Creates ViewModel instance. This would probably done using action method parameters. If null is specified then ViewModel will have its default value.
        /// After model is created then it's assigned to ViewData.Model property.
        /// </param>
        /// <param name="handleInitializeViewModelException">
        /// If non-null is specified then catches all exceptions during ViewModel initialization.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="handleInvalidViewModelAfterInitialization">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel initialization.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="obtainActionResult">
        /// Delegate that returns action result that will be returned from action method. If null then null is returned.
        /// </param>
        /// <param name="handleObtainActionResultException">
        /// If non-null is specified then catches all exceptions during action result obtaining.
        /// If some exception occurs then action method returns value that delegate returns.
        /// </param>
        /// <returns>Returns action result.</returns>
        /// <remarks>This method only should be called inside action method.</remarks>
        public static ActionResult ProcessGET<TViewModel>(this ControllerBase controller,
            Func<TViewModel> initializeViewModel, 
            Func<TViewModel, Exception, ActionResult> handleInitializeViewModelException, 
            Func<TViewModel, ActionResult> handleInvalidViewModelAfterInitialization,
            Func<TViewModel, ActionResult> obtainActionResult,
            Func<TViewModel, Exception, ActionResult> handleObtainActionResultException)
        {
            return Process<TViewModel>(controller,
                initializeViewModel,
                handleInitializeViewModelException,
                handleInvalidViewModelAfterInitialization,
                null,
                null,
                null,
                obtainActionResult,
                handleObtainActionResultException);
        }


        #endregion




        #region for POST action methods

        /// <summary>
        /// Provides the right action method template for action method that works on ViewModel (typically POST action methods).
        /// ViewModel is automatically created using parameterless constructor and assigned into ViewData.Model property.
        /// If some exception occurs during ViewModel initialization or update then this exception is added into ModelState.
        /// </summary>
        /// <typeparam name="TViewModel">ViewModel class that in used in this action method and related view.</typeparam>
        /// <param name="controller">Controller.</param>
        /// <param name="handleInvalidViewModelAfterInitialization">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel initialization.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="updateViewModel">Updates ViewModel.</param>
        /// <param name="handleInvalidViewModelAfterUpdate">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel update.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="obtainActionResult">
        /// Delegate that returns action result that will be returned from action method. If null then null is returned.
        /// </param>
        /// <returns>Returns action result.</returns>
        /// <remarks>This method only should be called inside action method.</remarks>
        public static ActionResult Process<TViewModel>(this ControllerBase controller,
            Func<TViewModel, ActionResult> handleInvalidViewModelAfterInitialization,
            Action<TViewModel> updateViewModel,
            Func<TViewModel, ActionResult> handleInvalidViewModelAfterUpdate,
            Func<TViewModel, ActionResult> obtainActionResult)
            where TViewModel : new()
        {
            return Process<TViewModel>(controller,
                () => new TViewModel(),
                handleInvalidViewModelAfterInitialization,
                updateViewModel,
                handleInvalidViewModelAfterUpdate,
                obtainActionResult);
        }



        /// <summary>
        /// Provides the right action method template. Provides the right action method template for action method that works on ViewModel (typically POST action methods).
        /// If some exception occurs during ViewModel initialization or update then this exception is added into ModelState.
        /// </summary>
        /// <typeparam name="TViewModel">ViewModel class that in used in this action method and related view.</typeparam>
        /// <param name="controller">Controller.</param>
        /// <param name="initializeViewModel">
        /// Creates ViewModel instance. This would probably done using action method parameters. If null is specified then ViewModel will have its default value.
        /// After model is created then it's assigned to ViewData.Model property.
        /// </param>
        /// <param name="handleInvalidViewModelAfterInitialization">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel initialization.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="updateViewModel">Updates ViewModel.</param>
        /// <param name="handleInvalidViewModelAfterUpdate">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel update.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="obtainActionResult">
        /// Delegate that returns action result that will be returned from action method. If null then null is returned.
        /// </param>
        /// <returns>Returns action result.</returns>
        /// <remarks>This method only should be called inside action method.</remarks>
        public static ActionResult Process<TViewModel>(this ControllerBase controller,
            Func<TViewModel> initializeViewModel, 
            Func<TViewModel, ActionResult> handleInvalidViewModelAfterInitialization,
            Action<TViewModel> updateViewModel, 
            Func<TViewModel, ActionResult> handleInvalidViewModelAfterUpdate,
            Func<TViewModel, ActionResult> obtainActionResult)
        {
            return Process<TViewModel>(controller,
                initializeViewModel,
                (viewModel, exception) => { controller.ViewData.ModelState.AddModelError("error", exception); return null; },
                handleInvalidViewModelAfterInitialization,
                updateViewModel,
                (viewModel, exception) => { controller.ViewData.ModelState.AddModelError("error", exception); return null; },
                handleInvalidViewModelAfterUpdate,
                obtainActionResult,
                null);
        }



        /// <summary>
        /// Provides the right action method template for action method that works on ViewModel (typically POST action methods).
        /// </summary>
        /// <typeparam name="TViewModel">ViewModel class that in used in this action method and related view.</typeparam>
        /// <param name="controller">Controller.</param>
        /// <param name="initializeViewModel">
        /// Creates ViewModel instance. This would probably done using action method parameters. If null is specified then ViewModel will have its default value.
        /// After model is created then it's assigned to ViewData.Model property.
        /// </param>
        /// <param name="handleInitializeViewModelException">
        /// If non-null is specified then catches all exceptions during ViewModel initialization.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="handleInvalidViewModelAfterInitialization">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel initialization.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="updateViewModel">Updates ViewModel.</param>
        /// <param name="handleUpdateViewModelException">
        /// If non-null is specified then catches all exceptions during ViewModel update.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="handleInvalidViewModelAfterUpdate">
        /// If some delegate is specified then allows to handle invalid ModelState after ViewModel update.
        /// If specified delegate returns non-null action result then current action method is terminated and this action result is used as return value.
        /// </param>
        /// <param name="obtainActionResult">
        /// Delegate that returns action result that will be returned from action method. If null then null is returned.
        /// </param>
        /// <param name="handleObtainActionResultException">
        /// If non-null is specified then catches all exceptions during action result obtaining.
        /// If some exception occurs then action method returns value that delegate returns.
        /// </param>
        /// <returns>Returns action result.</returns>
        /// <remarks>This method only should be called inside action method.</remarks>
    public static ActionResult Process<TViewModel>(this ControllerBase controller,
        Func<TViewModel> initializeViewModel, 
        Func<TViewModel, Exception, ActionResult> handleInitializeViewModelException, 
        Func<TViewModel, ActionResult> handleInvalidViewModelAfterInitialization,
        Action<TViewModel> updateViewModel, 
        Func<TViewModel, Exception, ActionResult> handleUpdateViewModelException, 
        Func<TViewModel, ActionResult> handleInvalidViewModelAfterUpdate,
        Func<TViewModel, ActionResult> obtainActionResult, 
        Func<TViewModel, Exception, ActionResult> handleObtainActionResultException)
        {
            if (controller == null)
            {
                throw new ArgumentNullException("controller");
            }

            var viewModel = default(TViewModel);

            // ViewModel initialization
            if (handleInitializeViewModelException != null)
            {
                try
                {
                    if (initializeViewModel != null)
                    {
                        viewModel = initializeViewModel();
                    }
                }
                catch (Exception e)
                {
                    var ar = handleInitializeViewModelException(viewModel, e);
                    if (ar != null)
                    {
                        return ar;
                    }
                }
            }
            else
            {
                if (initializeViewModel != null)
                {
                    viewModel = initializeViewModel();
                }
            }

            // set view-ViewModel (but not rewrite)
            if (controller.ViewData != null && controller.ViewData.Model == null)
            {
                controller.ViewData.Model = viewModel;
            }

            // post-initialize check
            if (!controller.ViewData.ModelState.IsValid && handleInvalidViewModelAfterInitialization != null)
            {
                var res = handleInvalidViewModelAfterInitialization(viewModel);
                if (res != null)
                {
                    return res;
                }
            }

            // ViewModel updating
            if (handleUpdateViewModelException != null)
            {
                try
                {
                    if (updateViewModel != null)
                    {
                        updateViewModel(viewModel);
                    }
                }
                catch (Exception e)
                {
                    var ar = handleUpdateViewModelException(viewModel, e);
                    if (ar != null)
                    {
                        return ar;
                    }
                }
            }
            else
            {
                if (updateViewModel != null)
                {
                    updateViewModel(viewModel);
                }
            }

            // post-update check
            if (handleInvalidViewModelAfterUpdate != null)
            {
                var res = handleInvalidViewModelAfterUpdate(viewModel);
                if (res != null)
                {
                    return res;
                }
            }


            if (handleObtainActionResultException != null)
            {
                try
                {
                    return obtainActionResult != null ? obtainActionResult(viewModel) : null;
                }
                catch (Exception e)
                {
                    return handleObtainActionResultException(viewModel, e);
                }
            }
            else
            {
                return obtainActionResult != null ? obtainActionResult(viewModel) : null;
            }
        }


        #endregion

    }
}