/**
 * Copyright 2005-2017 The Kuali Foundation
 *
 * Licensed under the Educational Community License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.opensource.org/licenses/ecl2.php
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.kuali.rice.kew.actionlist;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;
import org.kuali.rice.core.api.config.property.ConfigContext;
import org.kuali.rice.core.api.delegation.DelegationType;
import org.kuali.rice.core.api.exception.RiceIllegalArgumentException;
import org.kuali.rice.core.api.exception.RiceRuntimeException;
import org.kuali.rice.kew.actionitem.ActionItem;
import org.kuali.rice.kew.actionitem.ActionItemBase;
import org.kuali.rice.kew.actionitem.OutboxItem;
import org.kuali.rice.kew.actionlist.service.ActionListService;
import org.kuali.rice.kew.actionlist.web.ActionListUtil;
import org.kuali.rice.kew.actionrequest.Recipient;
import org.kuali.rice.kew.api.KewApiConstants;
import org.kuali.rice.kew.api.KewApiServiceLocator;
import org.kuali.rice.kew.api.action.ActionInvocation;
import org.kuali.rice.kew.api.action.ActionItemCustomization;
import org.kuali.rice.kew.api.action.ActionSet;
import org.kuali.rice.kew.api.action.ActionType;
import org.kuali.rice.kew.api.exception.WorkflowException;
import org.kuali.rice.kew.api.extension.ExtensionDefinition;
import org.kuali.rice.kew.api.preferences.Preferences;
import org.kuali.rice.kew.framework.KewFrameworkServiceLocator;
import org.kuali.rice.kew.framework.actionlist.ActionListCustomizationMediator;
import org.kuali.rice.kew.service.KEWServiceLocator;
import org.kuali.rice.kew.util.PerformanceLogger;
import org.kuali.rice.kim.api.identity.Person;
import org.kuali.rice.kim.api.identity.principal.Principal;
import org.kuali.rice.krad.UserSession;
import org.kuali.rice.krad.exception.AuthorizationException;
import org.kuali.rice.krad.uif.util.ObjectPropertyUtils;
import org.kuali.rice.krad.util.GlobalVariables;
import org.kuali.rice.krad.web.controller.MethodAccessible;
import org.kuali.rice.krad.web.controller.UifControllerBase;
import org.kuali.rice.krad.web.form.UifFormBase;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**
 * A controller for the action list view.
 *
 * @author Kuali Rice Team (rice.collab@kuali.org)
 */
@Controller
@RequestMapping(value = "/kew/actionList")
public class ActionListController extends UifControllerBase{
    private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(ActionListController.class);
    protected static final String MAX_ACTION_ITEM_DATE_FORMAT = "yyyy-MM-dd hh:mm:ss.S";

    private static final ActionType [] actionListActionTypes =
            { ActionType.APPROVE, ActionType.DISAPPROVE, ActionType.CANCEL, ActionType.ACKNOWLEDGE, ActionType.FYI };

    @Override
    protected ActionListForm createInitialForm() {
        return new ActionListForm();
    }

    /**
    * Refresh request mapping.
    *
    * <p>
    * Handles requests where the methodToCall parameter
    * is 'refresh'.
    * </p>
    *
    * @param form - ActionListForm form
    * @param result - Spring form binding result
    * @param request - http request
    * @param response - http response
    * @return start - forwards to start method
    */
    @Override
    @RequestMapping(params = "methodToCall=refresh")
    public ModelAndView refresh(UifFormBase form){
        ActionListForm actionListForm = (ActionListForm)form;
        actionListForm.setRequeryActionList(true);

        return start(form);
    }

    /**
    * Initializes filter.
    *
    * <p>
    * Sets up the action list filter
    * </p>
    *
    * @param form - ActionListForm form
    */
    protected void initializeFilter(ActionListForm form) {
        if (form.getFilter() == null) {
            ActionListFilter filter = new ActionListFilter();
            filter.setDelegationType(DelegationType.SECONDARY.getCode());
            filter.setExcludeDelegationType(true);
            form.setFilter(filter);
        }
    }

    /**
    * Initializes principal id.
    *
    * <p>
    * Sets up the principal id in the form.
    * </p>
    *
    * @param actionListForm - ActionListForm form
    * @param filter - action list filter
    * @return String
    */
    protected String initializePrincipalId(ActionListForm actionListForm,ActionListFilter filter) {
        String principalId = null;
        Principal principal = actionListForm.getHelpDeskActionListPrincipal();
        if (principal != null) {
            principalId = principal.getPrincipalId();
        } else {
            if (!StringUtils.isEmpty(actionListForm.getDocType())) {
                initializeDocType(actionListForm,filter);
            }
            final UserSession uSession = getUserSession();
            principalId = uSession.getPerson().getPrincipalId();
        }

        return principalId;
    }

    /**
    * Initializes Document Type.
    *
    * <p>
    * Sets up the document type in the form.
    * </p>
    *
    * @param actionListForm - ActionListForm form
    * @param filter - action list filter
    * @return void
    */
    protected void initializeDocType(ActionListForm actionListForm,ActionListFilter filter) {
        filter.setDocumentType(actionListForm.getDocType());
        filter.setExcludeDocumentType(false);
        actionListForm.setRequeryActionList(true);
    }

    /**
    * Initializes Delegators
    *
    * <p>
    * Sets up the delegators for the form and filter
    * </p>
    *
    * @param actionListForm - ActionListForm form
    * @param filter - action list filter
    * @param actionList - list of action items
    * @param request - http request
    * @return void
    */
    protected void initializeDelegators(ActionListForm actionListForm,ActionListFilter filter,List<? extends ActionItemBase> actionList,HttpServletRequest request)   {
        if (!KewApiConstants.DELEGATION_DEFAULT.equals(actionListForm.getDelegationId())) {
            // If the user can filter by both primary and secondary delegation, and both drop-downs have non-default values assigned,
            // then reset the primary delegation drop-down's value when the primary delegation drop-down's value has remained unaltered
            // but the secondary drop-down's value has been altered; but if one of these alteration situations does not apply, reset the
            // secondary delegation drop-down.

            if (StringUtils.isNotBlank(actionListForm.getPrimaryDelegateId()) && !KewApiConstants.PRIMARY_DELEGATION_DEFAULT.equals(actionListForm.getPrimaryDelegateId())){
                setDelegationId(actionListForm,request);
            } else if (StringUtils.isNotBlank(filter.getPrimaryDelegateId()) &&
                    !KewApiConstants.PRIMARY_DELEGATION_DEFAULT.equals(filter.getPrimaryDelegateId())) {
                // If the primary delegation drop-down is invisible but a primary delegation filter is in place, and if the secondary delegation
                // drop-down has a non-default value selected, then reset the primary delegation filtering.
                filter.setPrimaryDelegateId(KewApiConstants.PRIMARY_DELEGATION_DEFAULT);
            }
        }
        // Enable the secondary delegation filtering.
        filter.setDelegatorId(actionListForm.getDelegationId());
        filter.setExcludeDelegatorId(false);
        actionList = null;
    }

    /**
     * Sets the delegation id
     *
     * <p>
     * Sets the delegation id on the form
     * </p>
     *
     * @param actionListForm - ActionListForm form
     * @param request - http request
     * @return void
     */
    protected void setDelegationId(ActionListForm actionListForm,HttpServletRequest request)   {
        if (actionListForm.getPrimaryDelegateId().equals(request.getParameter("oldPrimaryDelegateId")) &&
                !actionListForm.getDelegationId().equals(request.getParameter("oldDelegationId"))) {
            actionListForm.setPrimaryDelegateId(KewApiConstants.PRIMARY_DELEGATION_DEFAULT);
        } else {
            actionListForm.setDelegationId(KewApiConstants.DELEGATION_DEFAULT);
        }
    }

    /**
     * Initializes primary delegate.
     *
     * <p>
     * Sets up the primary delegate in the form.
     * </p>
     *
     * @param actionListForm - ActionListForm form
     * @param filter - action list filter
     * @param actionList - list of action items
     * @param request - http request
     * @return void
     */
    protected void initializePrimaryDelegate(ActionListForm actionListForm,ActionListFilter filter,List<? extends ActionItemBase> actionList,HttpServletRequest request)   {
        if (!StringUtils.isEmpty(actionListForm.getPrimaryDelegateId())) {

            // If the secondary delegation drop-down is invisible but a secondary delegation filter is in place, and if the primary delegation
            // drop-down has a non-default value selected, then reset the secondary delegation filtering.
            if (StringUtils.isBlank(actionListForm.getDelegationId()) && !KewApiConstants.PRIMARY_DELEGATION_DEFAULT.equals(actionListForm.getPrimaryDelegateId()) &&
                    StringUtils.isNotBlank(filter.getDelegatorId()) &&
                    !KewApiConstants.DELEGATION_DEFAULT.equals(filter.getDelegatorId())) {
                filter.setDelegatorId(KewApiConstants.DELEGATION_DEFAULT);
            }

            // Enable the primary delegation filtering.
            filter.setPrimaryDelegateId(actionListForm.getPrimaryDelegateId());
            filter.setExcludeDelegatorId(false);
            actionList = null;
        }
    }

    /**
    * Start request mapping.
    *
    * <p>
    * Handles requests where the methodToCall parameter
    * is 'start'.  Runs on most requests and sets up the
    * basic variables.
    * </p>
    *
    * @param form - ActionListForm form
    * @param request - http request
    * @param response - http response
    * @return ModelAndView - uses standard KRAD getModelAndView()
    */
    @Override
    @MethodAccessible
    @RequestMapping(params = "methodToCall=start")
    public ModelAndView start(UifFormBase form) {
        ActionListForm actionListForm = (ActionListForm)form;
        HttpServletRequest request = actionListForm.getRequest();

        //Get preferences if they don't exist
        if( actionListForm.getPreferences() == null){
            actionListForm.setPreferences(KewApiServiceLocator.getPreferencesService().getPreferences(
                    getUserSession().getPrincipalId()));

        };
        request.setAttribute("preferences", actionListForm.getPreferences());

        PerformanceLogger plog = new PerformanceLogger();
        plog.log("Starting ActionList fetch");
        ActionListService actionListSrv = KEWServiceLocator.getActionListService();

        // reset the default action on tdhe form
        actionListForm.setDefaultActionToTake("NONE");
        boolean freshActionList = true;

        // retrieve cached action list
        List<? extends ActionItemBase> actionList = actionListForm.getActionList();
        plog.log("Time to initialize");


        try {

            initializeFilter(actionListForm);
            final ActionListFilter filter = actionListForm.getFilter();

            String principalId = initializePrincipalId(actionListForm,filter);

            /* 'forceListRefresh' variable used to signify that the action list filter has changed
             * any time the filter changes the action list must be refreshed or filter may not take effect on existing
             * list items... only exception is if action list has not loaded previous and fetching of the list has not
             * occurred yet
             */
            boolean forceListRefresh = actionListForm.isRequeryActionList();

            final Preferences preferences = actionListForm.getPreferences();

            //set primary delegation id
            if (!StringUtils.isEmpty(actionListForm.getDelegationId())) {
                initializeDelegators(actionListForm,filter,actionList,request);
            }

            //set primary delegate
            if (!StringUtils.isEmpty(actionListForm.getPrimaryDelegateId())) {
                initializePrimaryDelegate(actionListForm,filter,actionList,request);
            }

            // if the user has changed, we need to refresh the action list
            if (!principalId.equals(actionListForm.getUser())) {
                actionList = null;
            }

            if (isOutboxMode(actionListForm, request, preferences)) {
                actionList = new ArrayList<OutboxItem>(actionListSrv.getOutbox(principalId, filter));
                actionListForm.setOutBoxEmpty(actionList.isEmpty());
                //added because we now use the actionList rather than the actionListPage
                actionListForm.setActionList((ArrayList) actionList);
            } else {

                if (actionList == null) {
                    // fetch the action list
                    actionList = new ArrayList<ActionItem>(actionListSrv.getActionList(principalId, filter));
                    actionListForm.setUser(principalId);
                } else if (forceListRefresh) {
                    // force a refresh... usually based on filter change or parameter specifying refresh needed
                    actionList = new ArrayList<ActionItem>(actionListSrv.getActionList(principalId, filter));
                    actionListForm.setUser(principalId);
                } else {
                    Boolean update = actionListForm.isUpdateActionList();
                }

                actionListForm.setActionList((ArrayList) actionList);
            }

            // reset the requery action list key
            actionListForm.setRequeryActionList(false);

            // build the drop-down of delegators
            if (KewApiConstants.DELEGATORS_ON_ACTION_LIST_PAGE.equalsIgnoreCase(preferences.getDelegatorFilter())) {
                Collection<Recipient> delegators = actionListSrv.findUserSecondaryDelegators(principalId);
                actionListForm.setDelegators(ActionListUtil.getWebFriendlyRecipients(delegators));
                actionListForm.setDelegationId(filter.getDelegatorId());
            }

            // Build the drop-down of primary delegates.
            if (KewApiConstants.PRIMARY_DELEGATES_ON_ACTION_LIST_PAGE.equalsIgnoreCase(preferences.getPrimaryDelegateFilter())) {
                Collection<Recipient> pDelegates = actionListSrv.findUserPrimaryDelegations(principalId);
                actionListForm.setPrimaryDelegates(ActionListUtil.getWebFriendlyRecipients(pDelegates));
                actionListForm.setPrimaryDelegateId(filter.getPrimaryDelegateId());
            }

            actionListForm.setFilterLegend(filter.getFilterLegend());
            plog.log("Setting attributes");

            int pageSize = getPageSize(preferences);

            // initialize the action list if necessary
            if (freshActionList) {
                plog.log("calling initializeActionList");
                initializeActionList(actionList, preferences);
                plog.log("done w/ initializeActionList");
            }

            plog.log("start addActions");
            addCustomActions(actionList,preferences,actionListForm);
            plog.log("done w/ addCustomActions");
            actionListForm.setUpdateActionList(false);
            plog.log("finished setting attributes, finishing action list fetch");
        } catch (Exception e) {
            LOG.error("Error loading action list.", e);
        }

        LOG.debug("end start ActionListAction");

        String returnPage = "ActionListPage1";
        String methodToCall = actionListForm.getMethodToCall();
        if(methodToCall.equals("clear")) {
           returnPage = "ActionListPage2";
        }

        return getModelAndView(actionListForm, returnPage);
    }

    private static final String OUT_BOX_MODE = "_OUT_BOX_MODE";

    /**
    *  Determines whether the page is in outbox mode.
    *
    *  <p>
    *  This method is setting 2 props on the {@link org.kuali.rice.kew.actionlist.web.ActionListForm} that controls outbox behavior.
    *  alForm.setViewOutbox("false"); -> this is set by user preferences and the actionlist.outbox.off config prop
    *  alForm.setShowOutbox(false); -> this is set by user action clicking the ActionList vs. Outbox links.
    *  </p>
    *
    * @param alForm - action list form
    * @param request - http request
    * @return boolean indication whether the outbox should be fetched
    */
    private boolean isOutboxMode(ActionListForm alForm, HttpServletRequest request, Preferences preferences) {

        boolean outBoxView = false;

        if (! preferences.isUsingOutbox() || ! ConfigContext.getCurrentContextConfig().getOutBoxOn()) {
            alForm.setOutBoxMode(Boolean.FALSE);
            alForm.setViewOutbox("false");
            alForm.setShowOutbox(false);

            return false;
        }

        alForm.setShowOutbox(true);

        if (StringUtils.isNotEmpty(alForm.getViewOutbox())) {
            if (!Boolean.valueOf(alForm.getViewOutbox())) {
                //request.getSession().setAttribute(OUT_BOX_MODE, Boolean.FALSE);
                alForm.setOutBoxMode(Boolean.FALSE);
                outBoxView = false;
            } else {
                //request.getSession().setAttribute(OUT_BOX_MODE, Boolean.TRUE);
                alForm.setOutBoxMode(Boolean.FALSE);
                outBoxView = true;
            }
        } else {
            outBoxView = alForm.isOutBoxMode();
        }

        if (outBoxView) {
            alForm.setViewOutbox("true");
        } else {
            alForm.setViewOutbox("false");
        }

        return outBoxView;
    }

    /**
     *  Initializes the action list.
     *
     *  <p>
     *  Checks for errors in the action list upon initial load.
     *  </p>
     *
     * @param actionList list of action items
     * @param preferences KEW user preferences
     * @return void
     */
    private void initializeActionList(List<? extends ActionItemBase> actionList, Preferences preferences) {
        List<String> actionItemProblemIds = new ArrayList<String>();
        int index = 0;
        generateActionItemErrors(actionList);

        for (Iterator<? extends ActionItemBase> iterator = actionList.iterator(); iterator.hasNext();) {
            ActionItemBase actionItem = iterator.next();
            if (actionItem.getDocumentId() == null) {
                LOG.error("Somehow there exists an ActionItem with a null document id!  actionItemId=" + actionItem.getId());
                iterator.remove();
                continue;
            }

            try {
                actionItem.initialize(preferences);
                actionItem.setActionListIndex(index);
                index++;
            } catch (Exception e) {
                // if there's a problem loading the action item, we don't want to blow out the whole screen but we will remove it from the list
                // and display an appropriate error message to the user
                LOG.error("Error loading action list for action item " + actionItem.getId(), e);
                iterator.remove();
                actionItemProblemIds.add(actionItem.getDocumentId());
            }
        }

        generateActionItemErrors("actionitem", "actionlist.badActionItems", actionItemProblemIds);
    }

    /**
    *  Get the action list page size.
    *
    *  <p>
    *  Gets the page size of the Action List.  Uses the user's preferences for page size unless the action list
    *  has been throttled by an application constant, in which case it uses the smaller of the two values.
    *  </p>
    *
    * @param preferences KEW user preferences
    * @return int
    */
    protected int getPageSize(Preferences preferences) {
        return Integer.parseInt(preferences.getPageSize());
    }

    /**
    *  Adds custom actions to action items.
    *
    *  <p>
    *  Goes through each item in the action list and adds the custom actions.  It also adds flags for whether each
    *  item has actions.  Finally, creates list of actions and flag for the entire action list.
    *  </p>
    *
    * @param actionList list of action items
    * @param preferences KEW preferences
    * @form action list form
    * @return void
    */
    protected void addCustomActions(List<? extends ActionItemBase> actionList,
            Preferences preferences, ActionListForm form) throws WorkflowException {

        boolean haveCustomActions = false;
        boolean haveDisplayParameters = false;

        final boolean showClearFyi = KewApiConstants.PREFERENCES_YES_VAL.equalsIgnoreCase(preferences.getShowClearFyi());

        // collects all the actions for items
        Set<ActionType> pageActions = new HashSet<ActionType>();

        List<String> customActionListProblemIds = new ArrayList<String>();
        generateActionItemErrors(actionList);

        LOG.info("Beginning processing of Action List Customizations (total: " + actionList.size() + " Action Items)");
        long start = System.currentTimeMillis();
        Map<String, ActionItemCustomization> customizationMap =
                getActionListCustomizationMediator().getActionListCustomizations(
                        getUserSession().getPrincipalId(), convertToApiActionItems(actionList)
                );
        long end = System.currentTimeMillis();
        LOG.info("Finished processing of Action List Customizations (total time: " + (end - start) + " ms)");

        for(ActionItemBase actionItem : actionList ){
            // evaluate custom action list component for mass actions
            try {
                ActionItemCustomization customization = customizationMap.get(actionItem.getId());

                if (customization != null) {
                    ActionSet actionSet = customization.getActionSet();

                    // If only it were this easy: actionItem.setCustomActions(customization.getActionSet());
                    Map<String, String> customActions = new LinkedHashMap<String, String>();
                    customActions.put("NONE", "NONE");

                    for (ActionType actionType : actionListActionTypes) {
                        if (actionSet.hasAction(actionType.getCode()) &&
                                isActionCompatibleRequest(actionItem, actionType.getCode())) {
                            final boolean isFyi = ActionType.FYI == actionType; // make the conditional easier to read
                            if (!isFyi || (isFyi && showClearFyi)) { // deal with special FYI preference
                                customActions.put(actionType.getCode(), actionType.getLabel());
                                pageActions.add(actionType);
                            }
                        }
                    }

                    if (customActions.size() > 1) {
                        actionItem.setCustomActions(customActions);
                        haveCustomActions = true;
                    }

                    actionItem.setDisplayParameters(customization.getDisplayParameters());
                    haveDisplayParameters = haveDisplayParameters || (actionItem.getDisplayParameters() != null);
                }

            } catch (Exception e) {
                // if there's a problem loading the custom action list attribute, let's go ahead and display the vanilla action item
                LOG.error("Problem loading custom action list attribute", e);
                customActionListProblemIds.add(actionItem.getDocumentId());
            }
        }

        // configure custom actions on form
        form.setHasCustomActions(haveCustomActions);

        Map<String, String> defaultActions = new LinkedHashMap<String, String>();
        defaultActions.put("NONE", "NONE");

        for (ActionType actionType : actionListActionTypes) {
            if (pageActions.contains(actionType)) {
                // special logic for FYIs:
                final boolean isFyi = ActionType.FYI == actionType;
                if (isFyi) {
                    // clearing FYIs can be done in any action list not just a customized one
                    if(showClearFyi) {
                        defaultActions.put(actionType.getCode(), actionType.getLabel());
                    }
                } else { // all the other actions
                    defaultActions.put(actionType.getCode(), actionType.getLabel());
                    form.setCustomActionList(Boolean.TRUE);
                }
            }
        }

        if (defaultActions.size() > 1) {
            form.setDefaultActions(defaultActions);
        }

        form.setHasDisplayParameters(haveDisplayParameters);
        generateActionItemErrors("customActionList", "actionlist.badCustomActionListItems", customActionListProblemIds);

    }

    /**
    *  Converts actionItems to list.
    *
    *  <p>
    *  Convert a List of org.kuali.rice.kew.actionitem.ActionItemS to org.kuali.rice.kew.api.action.ActionItemS.
    *  </p>
    *
    * @param actionList list of action items
    * @return List<org.kuali.rice.kew.api.action.ActionItem>
    */
    private List<org.kuali.rice.kew.api.action.ActionItem> convertToApiActionItems(List<? extends ActionItemBase> actionList) {
        List<org.kuali.rice.kew.api.action.ActionItem> apiActionItems = new ArrayList<org.kuali.rice.kew.api.action.ActionItem>(actionList.size());
        for (ActionItemBase actionItemObj : actionList) {
            apiActionItems.add(
                    org.kuali.rice.kew.api.action.ActionItem.Builder.create(actionItemObj).build());
        }

        return apiActionItems;
    }

    /**
    *  Creates action item errors.
    *
    *  <p>
    *  Creates an error for each action item that has an empty ID.
    *  </p>
    *
    * @param propertyName the property name
    * @param errorKey  string of the error key
    * @param documentIds list of document IDs
    * @return void
    */
    private void generateActionItemErrors(String propertyName, String errorKey, List<String> documentIds) {
        if (!documentIds.isEmpty()) {
            String documentIdsString = StringUtils.join(documentIds.iterator(), ", ");
            GlobalVariables.getMessageMap().putError(propertyName, errorKey, documentIdsString);
        }
    }

    /**
    *  Creates action item errors.
    *
    *  <p>
    *  Creates an error for each action item that has an empty ID.
    *  </p>
    *
    * @param actionList list of action items.
    * @return void
    */
    private void generateActionItemErrors(List<? extends ActionItemBase> actionList) {
        for (ActionItemBase actionItem : actionList) {
            if(!KewApiConstants.ACTION_REQUEST_CODES.containsKey(actionItem.getActionRequestCd())) {
                GlobalVariables.getMessageMap().putError("actionRequestCd","actionitem.actionrequestcd.invalid",actionItem.getId()+"");
            }
        }
    }

    /**
     * Process taking mass action on action items
     *
     * <p>
     * Handles requests where the methodToCall parameter
     * is 'takeMassActions'.  Iterates through action items that have custom actions and process each selected action.
     * </p>
     *
     * @param form - ActionListForm form
     * @param result - Spring form binding result
     * @param request - http request
     * @param response - http response
     * @return start - forwards to the start method
     */
    @RequestMapping(params = "methodToCall=takeMassActions")
    protected ModelAndView takeMassActions(UifFormBase form){
        ActionListForm actionListForm = (ActionListForm) form;

        Object obj = ObjectPropertyUtils.getPropertyValue(form, "extensionData['actionInputField_actionSelect_line2']");

        List<? extends ActionItemBase> actionList = actionListForm.getActionList();
        if (actionList == null) {
            return getModelAndView(form);
        }

        ActionMessages messages = new ActionMessages();
        List<ActionInvocation> invocations = new ArrayList<ActionInvocation>();

        int index = 0;
        for (Object element : actionListForm.getActionsToTake()) {
            ActionToTake actionToTake = (ActionToTake) element;
            if (actionToTake != null && actionToTake.getActionTakenCd() != null &&
                    !"".equals(actionToTake.getActionTakenCd()) &&
                    !"NONE".equalsIgnoreCase(actionToTake.getActionTakenCd()) &&
                    actionToTake.getActionItemId() != null) {
                ActionItemBase actionItem = getActionItemFromActionList(actionList, actionToTake.getActionItemId());
                if (actionItem == null) {
                    LOG.warn("Could not locate the ActionItem to take mass action against in the action list: " + actionToTake.getActionItemId());
                    continue;
                }
                invocations.add(ActionInvocation.create(ActionType.fromCode(actionToTake.getActionTakenCd()), actionItem.getId()));
            }
            index++;
        }

        KEWServiceLocator.getWorkflowDocumentService().takeMassActions(getUserSession().getPrincipalId(), invocations);
        messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("general.routing.processed"));

        org.kuali.rice.kew.actionlist.web.ActionListForm
                cleanForm = new org.kuali.rice.kew.actionlist.web.ActionListForm();
        actionListForm.setRequeryActionList(true);

        return start(actionListForm);
    }

    /**
    * Gets action item from list.
    *
    * <p>
    * Gets the action item from the action item list based on the ID.
    * </p>
    *
    * @param actionList - list of action items
    * @param actionItemId - primary key for action item
    * @return ActionItem or null
    */
    protected ActionItemBase getActionItemFromActionList(List<? extends ActionItemBase> actionList, String actionItemId) {
        for (ActionItemBase actionItem : actionList) {
            if (actionItem.getId().equals(actionItemId)) {
                return actionItem;
            }
        }

        return null;
    }

    /**
     * Sets up view for help desk login.
     *
     * <p>
     * Setups the view for the help desk login.  User can see other's action items but can't take action on them.
     * </p>
     *
     * @param form - ActionListForm form
     * @param result - Spring form binding result
     * @param request - http request
     * @param response - http response
     * @return start() - forwards to start method to refresh action list
     */
    @MethodAccessible
    @RequestMapping(params = "methodToCall=helpDeskActionListLogin")
    public ModelAndView helpDeskActionListLogin(UifFormBase form){
        ActionListForm actionListForm = (ActionListForm) form;

        String name = actionListForm.getHelpDeskActionListUserName();
        if (!actionListForm.isHelpDeskActionList()) {
            throw new AuthorizationException(getUserSession().getPrincipalId(), "helpDeskActionListLogin", getClass().getSimpleName());
        }

        try
        {
            final Principal helpDeskActionListPrincipal = KEWServiceLocator.getIdentityHelperService().getPrincipalByPrincipalName(name);
            final Person helpDeskActionListPerson = KEWServiceLocator.getIdentityHelperService().getPersonByPrincipalName(name);
            actionListForm.setHelpDeskActionListPrincipal(helpDeskActionListPrincipal);
            actionListForm.setHelpDeskActionListPerson(helpDeskActionListPerson);
        }
        catch (RiceRuntimeException rre)
        {
            GlobalVariables.getMessageMap().putError("helpDeskActionListUserName", "helpdesk.login.invalid", name);
        }
        catch (RiceIllegalArgumentException e) {
            GlobalVariables.getMessageMap().putError("helpDeskActionListUserName", "helpdesk.login.invalid", name);
        }
        catch (NullPointerException npe)
        {
            GlobalVariables.getMessageMap().putError("null", "helpdesk.login.empty", name);
        }

        actionListForm.setDelegator(null);
        actionListForm.setRequeryActionList(true);

        return start(actionListForm);
    }

    /**
    * Clears the action list filter.
    *
    * <p>
    * Clears the action list filter so all action items are shown.
    * </p>
    *
    * @param form - ActionListForm form
    * @param result - Spring form binding result
    * @param request - http request
    * @param response - http response
    * @return start() - forwards to start to refresh action list
    */
    @RequestMapping(params = "methodToCall=clearFilter")
    public ModelAndView clearFilter(UifFormBase form){
        ActionListForm actionListForm = (ActionListForm) form;

        LOG.debug("clearFilter ActionListController");
        final org.kuali.rice.krad.UserSession commonUserSession = getUserSession();
        actionListForm.setFilter(new ActionListFilter());
        ActionListFilter filter = new ActionListFilter();
        filter.setDelegationType(DelegationType.SECONDARY.getCode());
        filter.setExcludeDelegationType(true);
        actionListForm.setFilter(filter);
        LOG.debug("end clearFilter ActionListController");

        return start(actionListForm);
    }

    /**
    * Clears the action list filter.
    *
    * <p>
    * Clears the action list filter so all action items are shown.  Clears filter from secondary page and then
    * forwards to the correct page after the start method runs.
    * </p>
    *
    * @param form ActionListForm form
    * @return clearFilter() - forwards to clearFilter method
    */
    @RequestMapping(params = "methodToCall=clear")
    public ModelAndView clear(UifFormBase form){
        return clearFilter(form);
    }

    /**
    * Sets the filter.
    *
    * <p>
    * Sets the action list filter in the form.
    * </p>
    *
    * @param form - ActionListForm form
    * @param result - Spring form binding result
    * @param request - http request
    * @param response - http response
    * @return start() forwards to start method to refresh action list
    */
    @RequestMapping(params = "methodToCall=setFilter")
    public ModelAndView setFilter(UifFormBase form){
        ActionListForm actionListForm = (ActionListForm) form;

        //validate the filter through the actionitem/actionlist service (I'm thinking actionlistservice)
        final UserSession uSession = getUserSession();

        ActionListFilter alFilter = actionListForm.getLoadedFilter();
        if (StringUtils.isNotBlank(alFilter.getDelegatorId()) && !KewApiConstants.DELEGATION_DEFAULT.equals(alFilter.getDelegatorId()) &&
                StringUtils.isNotBlank(alFilter.getPrimaryDelegateId()) && !KewApiConstants.PRIMARY_DELEGATION_DEFAULT.equals(alFilter.getPrimaryDelegateId())){
            // If the primary and secondary delegation drop-downs are both visible and are both set to non-default values,
            // then reset the secondary delegation drop-down to its default value.
            alFilter.setDelegatorId(KewApiConstants.DELEGATION_DEFAULT);
        }

        actionListForm.setFilter(alFilter);
        if (GlobalVariables.getMessageMap().hasNoErrors()) {
            actionListForm.setRequeryActionList(true);
            return start(actionListForm);
        }

        return start(actionListForm);
    }

    /**
    * Clears help desk login.
    *
    * <p>
    * Set the form back to display the logged in user's action list.
    * </p>
    *
    * @param form - ActionListForm form
    * @return start() - forwards to start method to refresh the action list
    */
    @RequestMapping(params = "methodToCall=clearHelpDeskActionListUser")
    public ModelAndView clearHelpDeskActionListUser(UifFormBase form){
        ActionListForm actionListForm = (ActionListForm) form;

        LOG.debug("clearHelpDeskActionListUser ActionListAction");
        actionListForm.setHelpDeskActionListPrincipal(null);
        actionListForm.setHelpDeskActionListPerson(null);
        LOG.debug("end clearHelpDeskActionListUser ActionListAction");

        actionListForm.setRequeryActionList(true);

        return start(actionListForm);
    }

    /**
    * Removes outbox items.
    *
    * <p>
    * Removes any outbox items that are selected.
    * </p>
    *
    * @param form - ActionListForm form
    * @return start() forwards to start to refresh the outbox.
    */
    @RequestMapping(params = "methodToCall=removeOutboxItems")
    public ModelAndView removeOutboxItems(UifFormBase form){
        ActionListForm actionListForm = (ActionListForm)form;
        Map selectedCollectionLines = actionListForm.getSelectedCollectionLines();
        Object selectedItems = selectedCollectionLines.get("ActionList");

        if (selectedItems != null) {
            List<String> outboxItemsForDeletion = new ArrayList<String>((LinkedHashSet)selectedItems);
            KEWServiceLocator.getActionListService().removeOutboxItems(getUserSession().getPrincipalId(), outboxItemsForDeletion);
            selectedCollectionLines.remove("ActionList");
            actionListForm.setSelectedCollectionLines(selectedCollectionLines);
        }

        actionListForm.setViewOutbox("true");
        actionListForm.setRequeryActionList(true);

        return start(actionListForm);
    }

    /**
    * Navigates to filter view.
    *
    * <p>
    * Navigate to the Action List Filter page, preserving any newly-modified primary/secondary delegation filters as necessary.
    * </p>
    *
    * @param form - ActionListForm form
    * @param result - Spring form binding result
    * @param request - http request
    * @param response - http response
    * @return ModelAndView - forwards to the standard KRAD getModelAndView method
    */
    @RequestMapping(params = "methodToCall=viewFilter")
    public ModelAndView viewFilter(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
            HttpServletRequest request, HttpServletResponse response){
        ActionListForm actionListForm = (ActionListForm)form;
        actionListForm.setOldFilter(new ActionListFilter(actionListForm.getFilter()));

        return getModelAndView(actionListForm, "ActionListPage2");
    }

    /**
    * Revert to previous filter.
    *
    * <p>
    * When user changes the filter but presses cancel, the filter goes back to the old filter.
    * </p>
    *
    * @param form - ActionListForm form
    * @return start() forwards to start method to refresh teh action list
    */
    @RequestMapping(params = "methodToCall=cancelFilter")
    public ModelAndView cancelFilter(UifFormBase form){
        ActionListForm actionListForm = (ActionListForm)form;
        actionListForm.setFilter(new ActionListFilter(actionListForm.getOldFilter()));

        return start(actionListForm);
    }

    /**
    * Navigate to preferences page.
    *
    * <p>
    * Navigate to the user's Preferences page, preserving any newly-modified primary/secondary delegation filters as
    * necessary.
    * </p>
    *
    * @param form - ActionListForm form
    * @param result - Spring form binding result
    * @param request - http request
    * @param response - http response
    * @return ModelAndView - forwards to KRAD standard getModelAndView method
    */
    @RequestMapping(params = "methodToCall=viewPreferences")
    public ModelAndView viewPreferences(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
            HttpServletRequest request, HttpServletResponse response){
        return getModelAndView(form, "ActionListPage3");
    }

    /**
    * Is the action item a compatible request.
    *
    * <p>
    * Checks whether the action taken is valid for the action item.
    * </p>
    *
    * @param actionItem - an action item
    * @param actionTakenCode - code of action taken on the action item
    * @return boolean
    */
    private boolean isActionCompatibleRequest(ActionItemBase actionItem, String actionTakenCode) {
        boolean actionCompatible = false;
        String requestCd = actionItem.getActionRequestCd();

        //FYI request matches FYI
        if (KewApiConstants.ACTION_REQUEST_FYI_REQ.equals(requestCd) && KewApiConstants.ACTION_TAKEN_FYI_CD.equals(actionTakenCode)) {
            actionCompatible = true || actionCompatible;
        }

        // ACK request matches ACK
        if (KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ.equals(requestCd) && KewApiConstants.ACTION_TAKEN_ACKNOWLEDGED_CD.equals(actionTakenCode)) {
            actionCompatible = true || actionCompatible;
        }

        // APPROVE request matches all but FYI and ACK
        if (KewApiConstants.ACTION_REQUEST_APPROVE_REQ.equals(requestCd) && !(KewApiConstants.ACTION_TAKEN_FYI_CD.equals(actionTakenCode) || KewApiConstants.ACTION_TAKEN_ACKNOWLEDGED_CD.equals(actionTakenCode))) {
            actionCompatible = true || actionCompatible;
        }

        // COMPLETE request matches all but FYI and ACK
        if (KewApiConstants.ACTION_REQUEST_COMPLETE_REQ.equals(requestCd) && !(KewApiConstants.ACTION_TAKEN_FYI_CD.equals(actionTakenCode) || KewApiConstants.ACTION_TAKEN_ACKNOWLEDGED_CD.equals(actionTakenCode))) {
            actionCompatible = true || actionCompatible;
        }

        return actionCompatible;
    }

    /**
    * Gets session.
    *
    * <p>
    * Gets the user session object.
    * </p>
    *
    * @return UserSession
    */
    private UserSession getUserSession(){
        return GlobalVariables.getUserSession();
    }

    /**
    * Lazy initialization holder class
    *
    * <p>
    * Lazy initialization holder static class (see Effective Java Item #71)
    * </p>
    *
    */
    private static class ActionListCustomizationMediatorHolder {
        static final ActionListCustomizationMediator actionListCustomizationMediator =
                KewFrameworkServiceLocator.getActionListCustomizationMediator();
    }

    /**
    * Action list customization mediator.
    *
    * <p>
    * Action list customization mediator.
    * </p>
    *
    * @return ActionListCustomizationMediatorHolder.actionListCustomizationMediator
    */
    private ActionListCustomizationMediator getActionListCustomizationMediator() {
        return ActionListCustomizationMediatorHolder.actionListCustomizationMediator;
    }

    /**
    * Simple class which defines the key of a partition of Action Items associated with an Application ID.
    *
    * <p>
    * This class allows direct field access since it is intended for internal use only.
    * </p>
    *
    */
    private static final class PartitionKey {
        String applicationId;
        Set<String> customActionListAttributeNames;

        PartitionKey(String applicationId, Collection<ExtensionDefinition> extensionDefinitions) {
            this.applicationId = applicationId;
            this.customActionListAttributeNames = new HashSet<String>();
            for (ExtensionDefinition extensionDefinition : extensionDefinitions) {
                this.customActionListAttributeNames.add(extensionDefinition.getName());
            }
        }

        List<String> getCustomActionListAttributeNameList() {
            return new ArrayList<String>(customActionListAttributeNames);
        }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof PartitionKey)) {
                return false;
            }
            PartitionKey key = (PartitionKey) o;
            EqualsBuilder builder = new EqualsBuilder();
            builder.append(applicationId, key.applicationId);
            builder.append(customActionListAttributeNames, key.customActionListAttributeNames);

            return builder.isEquals();
        }

        @Override
        public int hashCode() {
            HashCodeBuilder builder = new HashCodeBuilder();
            builder.append(applicationId);
            builder.append(customActionListAttributeNames);

            return builder.hashCode();
        }
    }


}