package org.ngbw.web.actions;

import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.validation.SkipValidation;

import org.ngbw.sdk.Workbench;
import org.ngbw.sdk.WorkbenchSession;
import org.ngbw.sdk.core.shared.TaskRunStage;
import org.ngbw.sdk.database.Folder;
import org.ngbw.sdk.database.FolderItem;
import org.ngbw.sdk.database.SourceDocument;
import org.ngbw.sdk.database.Task;
import org.ngbw.sdk.database.TaskInputSourceDocument;
import org.ngbw.sdk.database.TaskLogMessage;
import org.ngbw.sdk.database.TaskRun;
import org.ngbw.sdk.database.TaskOutputSourceDocument;
import org.ngbw.sdk.database.User;
import org.ngbw.sdk.database.util.TaskSortableField;
import org.ngbw.sdk.database.Statistics;
import org.ngbw.sdk.api.tool.FileHandler;
import org.ngbw.sdk.api.tool.ToolConfig;
import org.ngbw.sdk.common.util.StringUtils;
import org.ngbw.sdk.tool.Tool;
import org.ngbw.sdk.database.RunStatus;
import org.ngbw.web.model.Page;
import org.ngbw.web.model.Tab;
import org.ngbw.web.model.TabbedPanel;
import org.ngbw.web.model.impl.ListPage;


/**
 * Struts action class to manage user tasks in the NGBW web application.
 *
 * @author Jeremy Carver
 * @author Tony Chen 
 */
@SuppressWarnings("serial")
public class ManageTasks extends DataManager
{
    private static final Logger logger = Logger.getLogger(ManageTasks.class);

    // session attribute key constants
    public static final String CURRENT_TASK = "currentTask";
    public static final String CURRENT_RUN = "currentRun";
    public static final String FOLDER_TASKS = "folderTasks";
    public static final String TASK_FOLDER = "taskFolder";
    public static final String INPUT_MAP = "inputMap";

    // parameter attribute key constants
    public static final String RUN = "run";

    // result constants
    public static final String DISPLAY_INPUT = "displayInput";
    public static final String DISPLAY_PARAMETERS = "displayParameters";
    public static final String DISPLAY_OUTPUT_LIST = "displayOutputList";
    public static final String DISPLAY_WORKING_DIRECTORY = "displayWorkingDirectory";

    // task tab properties
    public static final String TASK_PAGE_SIZE = "taskPageSize";

    // task action constants
    public static final String MOVE = "Move";
    public static final String COPY = "Copy";
    public static final String DELETE = "Delete Selected";

    // task stage constants
    public static final String READY = "READY";
    public static final String COMPLETED = "COMPLETED";

    // task list form properties
    private String taskAction;

    // task list page properties
    private Task inputTask;
    private Task outputTask;
    private Map<String, List<TaskInputSourceDocument>> input;
    private Map<String, List<TaskOutputSourceDocument>> output;


    // ================================================================
    // Action methods
    // ================================================================
    @SkipValidation
    @Override
    public String list ()
    {
        logger.info("BEGIN: list()::String");
        
        Folder folder = getRequestFolder(ID);
        
        if (folder == null)
        {
            folder = getCurrentFolder();
        }
        
        if (folder == null)
        {
            logger.error(reportUserError("You must select a folder to view its tasks."));
            return HOME;
        }
        else
        {
            if (isCurrentFolder(folder) == false)
            {
                setCurrentFolder(folder);
            }
        
            TabbedPanel<Task> tabs = getFolderTaskTabs();
            String tab = getRequestParameter(TAB);
            
            if (tab != null)
            {
                tabs.setCurrentTab(tab);
            }
            
            return LIST;
        }
    }


    @SkipValidation
    public String refresh ()
    {
        refreshFolderTaskTabs();
        return LIST;
    }


    @SkipValidation
    public String refreshStatus ()
    {
        Task ct = getCurrentTask(); 
        if (ct != null)
        {
            setCurrentTask(getSelectedTask(ct.getTaskId()));
        } 
        return SUCCESS;
    }

    @SkipValidation
    @Override
    public String display () 
    {
        String retVal = "DISPLAY";
        
        // get selected task ID from request param, if present
        String[] taskId = (String[]) getParameters().get(ID);
        String[] runNum = (String[]) getParameters().get(RUN);
        
        if (taskId != null && taskId.length > 0 && runNum != null && runNum.length > 0)
        {
            setCurrentTask(getSelectedTask(Long.parseLong(taskId[0])));
            setCurrentRun(Integer.parseInt(runNum[0]));
            retVal = DISPLAY;
        }
        else if (getCurrentTask() != null && getCurrentRun() != null)
        {
            retVal = DISPLAY;
        }
        else
        {
            addActionError("You must select a task to view its details.");
            retVal = LIST;
        }
        
        return retVal;
    }


    @SkipValidation
    public String displayInput ()
    {
        // get selected task ID from request param, if present
        String[] taskId = (String[]) getParameters().get(ID);
        String[] runNum = (String[]) getParameters().get(RUN);
        if (taskId != null && taskId.length > 0 && runNum != null && runNum.length > 0)
        {
            setCurrentTask(getSelectedTask(Long.parseLong(taskId[0])));
            setCurrentRun(Integer.parseInt(runNum[0]));
            return DISPLAY_INPUT;
        }
        else if (getCurrentTask() != null && getCurrentRun() != null)
        {
            return DISPLAY_INPUT;
        }
        else
        {
            addActionError("You must select a task to view its input.");
            return LIST;
        }
    }


    @SkipValidation
    public String displayWorkingDirectory ()
    {
        logger.debug("BEGIN: displayWorkingDirectory()::String");
        
        String retVal = DISPLAY_WORKING_DIRECTORY;
        
        // get selected task ID from request param, if present
        String[] taskId = (String[]) getParameters().get(ID);
        
        if (taskId != null && taskId.length > 0)
        {
            setCurrentTask(getSelectedTask(Long.parseLong(taskId[0])));
            retVal = DISPLAY_WORKING_DIRECTORY;
        }
        else if (getCurrentTask() != null)
        {
            retVal = DISPLAY_WORKING_DIRECTORY;
        }
        else
        {
            addActionError("You must select a task to view its working directory.");
            retVal = LIST;
        }
        
        logger.debug(String.format("RetVal=[%s]", retVal));
        logger.debug("END: displayWorkingDirectory()::String");
        
        return retVal; 
    }


    @SkipValidation
    public String displayParameters ()
    {
        // get selected task ID from request param, if present
        String[] taskId = (String[]) getParameters().get(ID);
        String[] runNum = (String[]) getParameters().get(RUN);
        if (taskId != null && taskId.length > 0 && runNum != null && runNum.length > 0)
        {
            setCurrentTask(getSelectedTask(Long.parseLong(taskId[0])));
            setCurrentRun(Integer.parseInt(runNum[0]));
            return DISPLAY_PARAMETERS;
        }
        else if (getCurrentTask() != null && getCurrentRun() != null)
        {
            return DISPLAY_PARAMETERS;
        }
        else
        {
            addActionError("You must select a task to view its parameters.");
            return LIST;
        }
    }


    @SkipValidation
    @Override
    public String delete ()
    {
        String retVal = LIST;
        
        String jobHandle = "";
        
        try
        {
            Task currentTask = getCurrentTask();
            
            if (currentTask == null)
            {
                logger.error(reportUserError("You must select a task to delete it."));
            }
            else
            {
                logger.debug(   
                    String.format(
                        "Task '%s', JH=[%s] is being deleted by user ...",
                        currentTask.getLabel(), 
                        currentTask.getJobHandle()));
                
                jobHandle = currentTask.getJobHandle();
                
                String taskLabel = currentTask.getLabel();
                
                if (deleteTask(currentTask))
                {
                    setCurrentTask(null);
                    reportUserMessage("Task \"" + taskLabel + "\" successfully deleted.");
                    refreshFolderTaskTabs();
                    
                    logger.debug(   
                        String.format(
                            "Task '%s', JH=[%s] successfully deleted.",
                            currentTask.getLabel(), 
                            currentTask.getJobHandle()));
                }
                else
                {
                    reportUserMessage("Task \"" + taskLabel + "\" could not be deleted.");
                    
                    logger.error(
                        String.format(
                            "Task '%s', JH=[%s] could not be deleted.",
                            currentTask.getLabel(), 
                            currentTask.getJobHandle()));
                    
                    retVal = DISPLAY;
                }
            }
            
            return retVal;
        }
        catch ( Throwable error )
        {
            logger.error("Error deleting Task [" + jobHandle + "]:", error);
            return ERROR;
        }
    }


    @SkipValidation
    @Override
    public String cancel ()
    {
        String taskAction = getTaskAction();
        if (taskAction == null)
        {
            addActionError("You must select an action to manipulate your tasks.");
        }
        else
        {
            Long[] selectedIds = getSelectedIds();
            if (selectedIds == null || selectedIds.length < 1)
            {
                addActionError("You must select one or more tasks to "
                        + taskAction.toLowerCase() + " them.");
            }
            else
            {
                /*
                 *
                 */
                String[] button = (String[]) getParameters().get("method:cancel");
                if (button != null && button.length > 0 && button[0].equals(DELETE))
                {
                    return deleteSelected();
                }
                /*
                 *
                 */
                Folder folder = getCurrentFolder();
                Long targetFolder = getTargetFolder();
                if (targetFolder == null)
                {
                    addActionError("You must select a target folder to "
                            + taskAction.toLowerCase() + " your tasks.");
                }
                else if (targetFolder.equals(folder.getFolderId()))
                {
                    addActionError("You must select a new folder to "
                            + taskAction.toLowerCase() + " your tasks into.");
                }
                else if (taskAction.equalsIgnoreCase(MOVE))
                {
                    int moved = moveSelectedTasks();
                    String result = moved
                            + " task";
                    if (moved != 1)
                    {
                        result += "s were ";
                    }
                    else
                    {
                        result += " was ";
                    }
                    result += "successfully moved.";
                    reportUserMessage(result);
                    refreshFolderTaskTabs();
                }
                else
                {
                    addActionError("You have requested an unrecognized task action, "
                            + "please select from the list below.");
                }
            }
        }
        return LIST;
    }


    @SkipValidation
    public String cancelSelected ()
    {
        Long[] selectedIds = getSelectedIds();
        if (selectedIds == null || selectedIds.length < 1)
        {
            addActionError("You must select one or more tasks to cancel them.");
        }
        else
        {
            int cancelled = cancelSelectedTasks();
            int remaining = selectedIds.length - cancelled;
            if (cancelled > 0)
            {
                String result = cancelled + " task";
                if (cancelled != 1)
                {
                    result += "s were ";
                }
                else
                {
                    result += " was ";
                }
                result += "successfully cancelled.";
                reportUserMessage(result);
                refreshFolderTaskTabs();
            }
            if (remaining > 0)
            {
                String result = remaining + " task";
                if (remaining != 1)
                {
                    result += "s";
                }
                result += " could not be cancelled.";
                logger.error(reportUserError(result));
            }
        }
        return LIST;
    }


    @SkipValidation
    @Override
    public String deleteSelected ()
    {
        Long[] selectedIds = getSelectedIds();
        if (selectedIds == null || selectedIds.length < 1)
        {
            addActionError("You must select one or more tasks to delete them.");
        }
        else
        {
            int deleted = deleteSelectedTasks();
            int remaining = selectedIds.length - deleted;
            if (deleted > 0)
            {
                String result = deleted + " task";
                if (deleted != 1)
                {
                    result += "s were ";
                }
                else
                {
                    result += " was ";
                }
                result += "successfully deleted.";
                reportUserMessage(result);
                refreshFolderTaskTabs();
            }
            if (remaining > 0)
            {
                String result = remaining + " task";
                if (remaining != 1)
                {
                    result += "s";
                }
                result += " could not be deleted.";
                logger.error(reportUserError(result));
            }
        }
        return LIST;
    }


    public String getTaskAction ()
    {
        return taskAction;
    }


    public void setTaskAction ( String taskAction )
    {
        this.taskAction = taskAction;
    }


    @SuppressWarnings("unchecked")
    public TabbedPanel<Task> getFolderTaskTabs ()
    {
        TabbedPanel<Task> folderTasks
                = (TabbedPanel<Task>) getSession().get(FOLDER_TASKS);
        if (folderTasks == null
                || folderTasks.isParentFolder(getCurrentFolder()) == false)
        {
            folderTasks = refreshFolderTaskTabs();
        }
        return folderTasks;
    }


    @SuppressWarnings("unchecked")
    public void setFolderTaskTabs ( TabbedPanel<Task> folderTasks )
    {
        getSession().put(FOLDER_TASKS, folderTasks);
    }


    public boolean hasFolderTasks ()
    {
        TabbedPanel<Task> folderTasks = getFolderTaskTabs();
        return (folderTasks != null && folderTasks.getTabs().getTotalNumberOfElements() > 0);
    }


    @Override
    public List<String> getTabLabels ()
    {
        TabbedPanel<Task> folderTasks = getFolderTaskTabs();
        if (folderTasks == null)
        {
            return null;
        }
        else
        {
            return folderTasks.getTabLabels();
        }
    }


    @Override
    public String getFirstTabLabel ()
    {
        TabbedPanel<Task> folderTasks = getFolderTaskTabs();
        if (folderTasks == null)
        {
            return null;
        }
        else
        {
            return folderTasks.getFirstTabLabel();
        }
    }


    @Override
    public String getCurrentTabLabel ()
    {
        TabbedPanel<Task> folderTasks = getFolderTaskTabs();
        if (folderTasks == null)
        {
            return null;
        }
        else
        {
            Tab<Task> currentTab = folderTasks.getCurrentTab();
            if (currentTab == null)
            {
                return null;
            }
            else
            {
                return currentTab.getLabel();
            }
        }
    }


    @Override
    public int getCurrentTabSize ()
    {
        TabbedPanel<Task> folderTasks = getFolderTaskTabs();
        if (folderTasks == null)
        {
            return 0;
        }
        else
        {
            return folderTasks.getCurrentTabSize();
        }
    }

    //TODO: add sort functionality to user interface

    public List<Task> getCurrentTaskTab ()
    {
        TabbedPanel<Task> folderTasks = getFolderTaskTabs();
        if (folderTasks == null)
        {
            return null;
        }
        else
        {
            return folderTasks.getCurrentTabContents();
        }
    }


    public String getLabel ( Task task )
    {
        if (task == null)
        {
            return null;
        }
        else
        {
            return truncateText(task.getLabel());
        }
    }


    public String getJobHandle ( Task task )
    {
        if (task == null)
        {
            return null;
        }
        else
        {
            return truncateText(task.getJobHandle());
        }
    }


    public String getOwner ( Task task )
    {
        if (task == null)
        {
            return null;
        }
        else
        {
            try
            {
                return task.getUser().getUsername();
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving username of user who owns task "
                            + task.getTaskId(), error);
                return null;
            }
        }
    }


    public String getGroup ( Task task )
    {
        if (task == null)
        {
            return null;
        }
        else
        {
            try
            {
                return task.getGroup().getGroupname();
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving group name of group that owns task "
                            + task.getTaskId(), error);
                return null;
            }
        }
    }


    public String getRunCreationDate ( Task task, int run )
    {
        if (task == null)
        {
            return null;
        }
        else
        {
            try
            {
                return formatDate(getRun(task, run).getCreationDate());
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving creation date of task "
                            + task.getTaskId(), error);
                return null;
            }
        }
    }


    public String getToolLabel ( Task task )
    {
        if (task == null)
        {
            return null;
        }
        else
        {
            return getToolLabel(task.getToolId());
        }
    }


    public boolean isNew ( Task task )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            TaskRunStage stage = getLatestRun(task).getStage();
            if (stage == null)
            {
                return false;
            }
            else
            {
                return stage.equals(TaskRunStage.NEW);
            }
        }
    }


    public boolean isReady ( Task task )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            TaskRunStage stage = getLatestRun(task).getStage();
            if (stage == null)
            {
                return false;
            }
            else
            {
                return stage.equals(TaskRunStage.READY);
            }
        }
    }


    public boolean isReady ( Task task, int run )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            TaskRunStage stage = getRun(task, run).getStage();
            if (stage == null)
            {
                return false;
            }
            else
            {
                return stage.equals(TaskRunStage.READY);
            }
        }
    }


    public boolean isCompleted ( Task task )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            TaskRunStage stage = getLatestRun(task).getStage();
            if (stage == null)
            {
                return false;
            }
            else
            {
                return stage.equals(TaskRunStage.COMPLETED);
            }
        }
    }

   public boolean isRestartSubmitFailed ( Task task )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            try
            {
                TaskRun last = task.runs().last();
                logger.info("TaskId = " + task.getTaskId() + " isRestart = " + last.isRestart() + " getStatus = " + last.getStage() + " isTerminal = " + last.isTerminal());

                if (last == null)
                {
                    return false;
                }
                else
                {
                    return (last.isRestart() && last.getStatus() == RunStatus.SUBMIT_FAIL && last.isTerminal());
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }
    }    
    public boolean isUneditable ( Task task )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            TaskRunStage stage = getLatestRun(task).getStage();
            if (stage == null)
            {
                return false;
            }
            else
            {
                return (stage.equals(TaskRunStage.COMPLETED) ||
                        stage.equals(TaskRunStage.SUBMITTED) ||
                        stage.equals(TaskRunStage.RUNNING) ||
                        stage.equals(TaskRunStage.LOAD_RESULTS));
            }
        }
    }
    
    public boolean isCompleted ( Task task, int run )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            TaskRunStage stage = getRun(task, run).getStage();
            if (stage == null)
            {
                return false;
            }
            else
            {
                return stage.equals(TaskRunStage.COMPLETED);
            }
        }
    }


    public boolean hasError ( Task task )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            return (getLatestRun(task).hasError());
        }
    }


    public boolean hasError ( Task task, int run )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            return (getRun(task, run).hasError());
        }
    }


    public boolean isRestartable ( Task task )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            Tool tool =  Workbench.getInstance().getTool(task.getToolId());
            ToolConfig config = tool.getToolConfig();

            return config.isRestartable();
        }
    }


    public boolean isTemporarySubmitProblem( Task task)
    {
        if (task != null)
        {
            RunStatus rs = getLatestRun(task).getStatus();
            
            if (rs.equals(RunStatus.TEMPORARY_COMMU) || rs.equals(RunStatus.TEMPORARY_PROBLEM) || rs.equals(RunStatus.RESUBMITTED))
            {
                int maxRestart = 0;
                try
                {
                    String maxRestartStr = Workbench.getInstance().getProperties().getProperty("submitJob.restartrun.maxruns");
                    if (maxRestartStr != null)
                        maxRestart = Integer.parseInt(maxRestartStr);
                }
                catch (NumberFormatException nfe)
                {
                }
                if (maxRestart > 0 && getLatestRun(task).getRunNumber() >= maxRestart)
                    return false;
                return true;
            }
        }
        return false;
    }
    
    public Set<TaskRun> getTaskRuns ( Task task )
    {
        if (task == null)
        {
            return null;
        }
        else
        {
            try
            {
                Set<TaskRun> runs = task.runs();
                if (runs.size() > 6)
                {
                    List<TaskRun> removeSet = new ArrayList<TaskRun>();
                    for (TaskRun tr : runs)
                    {
                        if (tr.getRunNumber() > 1 && (tr.getRunNumber() <= (runs.size()-5)) &&
                            !tr.isRestart() && (tr.getStatus() == RunStatus.TEMPORARY_COMMU || tr.getStatus() == RunStatus.TEMPORARY_PROBLEM))
                            removeSet.add(tr);
                    }
                    runs.removeAll(removeSet);
                }
                return runs;
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving task runs for task " + task.getTaskId(), error);
                logger.error(error.toString());
                return null;
            }
        }
    }


    public Folder getTaskFolder ()
    {
        return (Folder) getSessionAttribute(TASK_FOLDER);
    }


    public void setTaskFolder ( Folder folder )
    {
        setSessionAttribute(TASK_FOLDER, folder);
    }


    public Task getNewTask ()
    {
        Folder folder = getCurrentFolder();
        Folder taskFolder = getTaskFolder();
        if (folder == null || taskFolder == null
                || folder.getFolderId() != taskFolder.getFolderId())
        {
            return null;
        }
        else
        {
            // only return current task if it's transient,
            // otherwise it's not an editable new task
            Task task = getCurrentTask();
            if (task.isNew())
            {
                return task;
            }
            else
            {
                return null;
            }
        }
    }


    public boolean hasNewTask ()
    {
        return (getNewTask() != null);
    }


    @SuppressWarnings("unchecked")
    public Map<String, List<TaskInputSourceDocument>> getInputMap ()
    {
        return (Map<String, List<TaskInputSourceDocument>>) getSessionAttribute(INPUT_MAP);
    }


    public void setInputMap ( Map<String, List<TaskInputSourceDocument>> inputMap )
    {
        setSessionAttribute(INPUT_MAP, inputMap);
    }


    /**
     * Returns all "file" parameters, including the main input parameter
     *
     * @param task
     * @param run
     *
     * @return
     */
    public Map<String, List<TaskInputSourceDocument>> getInput ( Task task, int run )
    {
        try
        {
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            // first try the task input stored in the action
            else if (input != null && inputTask != null
                    && inputTask.equals(task))
            {
                return input;
            }
            // if not found, retrieve it from the workbench
            else
            {
                WorkbenchSession session = getWorkbenchSession();
                if (session == null)
                {
                    throw new NullPointerException("No session is present.");
                }
                else
                {
                    input = session.getInput(task, run);
                    inputTask = task;
                    return input;
                }
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving input from selected task", error);
            return null;
        }
    }


    /**
     * Returns only the main input parameter
     *
     * @param task
     * @param run
     *
     * @return
     */
    public List<TaskInputSourceDocument> getMainInput ( Task task, int run )
    {
        if (task == null)
        {
            return null;
        }
        else
        {
            String inputParam = getMainInputParameter(task.getToolId());
            
            if (inputParam == null)
            {
                return null;
            }
            else
            {
                Map<String, List<TaskInputSourceDocument>> input = getInput(task, run);
                if (input != null && input.containsKey(inputParam))
                {
                    return input.get(inputParam);
                }
                else
                {
                    return null;
                }
            }
        }
    }


    public boolean hasMainInput ( Task task, int run )
    {
        return (getMainInput(task, run) != null);
    }


    public int getMainInputCount ( Task task, int run )
    {
        List<TaskInputSourceDocument> mainInput = getMainInput(task, run);
        if (mainInput == null)
        {
            return 0;
        }
        else
        {
            return mainInput.size();
        }
    }


    /**
     * Returns all "file" parameters other than the main input parameter
     *
     * @param task
     * @param run
     *
     * @return
     */
    public Map<String, List<TaskInputSourceDocument>> getParameterInput ( Task task, int run )
    {
        Map<String, List<TaskInputSourceDocument>> input = getInput(task, run);
        if (input == null)
        {
            return null;
        }
        else
        {
            String inputParam = getMainInputParameter(task.getToolId());
            if (inputParam != null && input.containsKey(inputParam))
            {
                input = new HashMap<String, List<TaskInputSourceDocument>>(input);
                input.remove(inputParam);
            }
            return input;
        }
    }


    /**
     * Returns true if any parameters are set other than the main input parameter. This includes
     * primitive (String) parameters, as well as "file" (SourceDocument) parameters.
     * <p>
     * Algorithm: 1. If there are any primitive parameters, return true 2. If there are no file
     * parameters, return false 3. If there is more than one file parameter, return true (since only
     * one can be the main input) 4. If the one file parameter is the main input, return false 5.
     * Return true
     *
     * @param task
     * @param run
     *
     * @return
     */
    public boolean hasParameters ( Task task, int run )
    {
        if (task == null)
        {
            return false;
        }
        else
        {
            Map<String, String> parameters = null;
            try
            {
                parameters = task.toolParameters();
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving parameters for task \""
                            + task.getLabel() + "\"", error);
                return false;
            }
            if (parameters == null || parameters.size() < 1)
            {
                Map<String, List<TaskInputSourceDocument>> input = getInput(task, run);
                if (input == null || input.size() < 1)
                {
                    return false;
                }
                else if (input.size() == 1)
                {
                    String inputParam = getMainInputParameter(task.getToolId());
                    if (inputParam != null && input.containsKey(inputParam))
                    {
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                else
                {
                    return true;
                }
            }
            else
            {
                return true;
            }
        }
    }


    /**
     * Returns the number of set parameters both primitive and "file", not including the main input
     * parameter
     */
    public int getParameterCount ( Task task, int run )
    {
        if (task == null)
        {
            return 0;
        }
        else
        {
            int parameterCount = 0;
            Map<String, String> parameters = null;
            try
            {
                parameters = task.toolParameters();
            }
            catch ( Throwable error )
            {
                logger.error("Error retrieving parameters for task \""
                            + task.getLabel() + "\"", error);
                return 0;
            }
            if (parameters != null)
            {
                parameterCount += parameters.size();
            }
            Map<String, List<TaskInputSourceDocument>> parameterInput = getParameterInput(task, run);
            if (parameterInput != null)
            {
                parameterCount += parameterInput.size();
            }
            return parameterCount;
        }
    }


    public Map<String, List<TaskOutputSourceDocument>> getOutput ( Task task, int run )
    {
        try
        {
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            // first try the task output stored in the action
            else if (output != null && outputTask != null && outputTask.equals(task))
            {
                return output;
            }
            // if not found, retrieve it from the workbench
            else
            {
                WorkbenchSession session = getWorkbenchSession();
                if (session == null)
                {
                    throw new NullPointerException("No session is present.");
                }
                else
                {
                    output = session.getOutput(task, run);
                    outputTask = task;
                    return output;
                }
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving output from selected task.", error);
            return null;
        }
    }


    public boolean hasOutput ( Task task, int run )
    {
        Map<String, List<TaskOutputSourceDocument>> output = getOutput(task, run);
        if (output != null && output.size() > 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }


    public int getOutputCount ( Task task, int run )
    {
        Map<String, List<TaskOutputSourceDocument>> output = getOutput(task, run);
        if (output == null)
        {
            return 0;
        }
        else
        {
            return output.size();
        }
    }


    public boolean hasWorkingDirectory ( Task task ) throws Exception
    {
        return getWorkbenchSession().workingDirectoryExists(task);
    }


    public List<FileHandler.FileAttributes> getWorkingDirectoryList ( Task task )
    {
        try
        {
            return getWorkbenchSession().listWorkingDirectory(task);
        }
        catch ( Throwable error )
        {
            logger.error("Error getting list of working directory files for selected task.", error);
            return null;
        }
    }


    public Task getCurrentTask ()
    {
        Task task = (Task) getSessionAttribute(CURRENT_TASK);
        if (task != null)
            logger.info("getCurrentTask () - TaskId: "  + task.getTaskId() + " Userid: " + task.getUserId());
        else
            logger.info("getCurrentTask () - task is null");
        return (Task) getSessionAttribute(CURRENT_TASK);
    }


    public void setCurrentTask ( Task task )
    {
        if (task != null)
            logger.info("setCurrentTask () - TaskId: "  + task.getTaskId() + " Userid: " + task.getUserId());
                else
            logger.info("setCurrentTask () - task is null");
        setSessionAttribute(CURRENT_TASK, task);
    }


    public Integer getCurrentRun()
    {
        return (Integer) getSessionAttribute(CURRENT_RUN);
    }


    public void setCurrentRun ( Integer run )
    {
        setSessionAttribute(CURRENT_RUN, run);
    }


    public boolean isRefreshable ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                TaskRun latest = getLatestRun(task);
                return (isNew(task) == false && isReady(task, latest.getRunNumber()) == false
                        && isCompleted(task, latest.getRunNumber()) == false && latest.isOk());
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error determining whether current task is refreshable", error);
            return false;
        }
    }


    public Long getCurrentTaskId ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                return task.getTaskId();
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving database ID of current task", error);
            return null;
        }
    }


    public String getCurrentTaskLabel ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                return getLabel(task);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving label of current task", error);
            return null;
        }
    }


    public String getCurrentTaskOwner ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                return getOwner(task);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving owner of current task", error);
            return null;
        }
    }


    public String getCurrentTaskGroup ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                return getGroup(task);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving group of current task", error);
            return null;
        }
    }


    public String getCurrentTaskCreationDate ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                return formatDate(task.getCreationDate());
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving creation date of current task", error);
            return null;
        }
    }

    
    /** 
     * Returns ToolID from Task object. 
     * 
     * @deprecated 
     * 
     * <pre>
     * <strong>NOTE:</strong>
     * This method will be removed from future versions. 
     * Use {@link getToolId()}
     * </pre>
     * 
     * @return 
     */
    public String getTool ()
    {
        return getToolId();
    }
    
    
    /**
     * Returns ToolID from Task object.
     * 
     * @return 
     */
    public String getToolId ()
    {
        Task task = getCurrentTask();
        
        if (task == null) 
        {
            logger.error("No task is currently selected.");
            return null; 
        }
        
        return task.getToolId();
    }

    
    /**
     * Returns the Tool label. 
     * 
     * @deprecated 
     * <p>
     * <strong>This method has been deprecated and will be removed from future versions.</strong>
     * <p>
     * <strong>Use {@link getToolLabel(String)}</strong>
     * 
     * @return 
     */
    public String getToolLabel ()
    {
        return getToolLabel(getToolId());
    }


    public String getToolAction ()
    {
        String tool = getToolId();
        return (StringUtils.isNullOrEmpty(tool, true))? null : tool.toLowerCase();
    }


    public String getMainInputParameter ()
    {
        return getMainInputParameter(getToolId());
    }


    public boolean hasMainInput ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
              throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return hasMainInput(task, run);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error determining whether current task has main input", error);
            return false;
        }
    }


    public List<TaskInputSourceDocument> getMainInput ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
              throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return getMainInput(task, run);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving current task's main input", error);
            return null;
        }
    }


    public int getMainInputCount ()
    {
        List<TaskInputSourceDocument> mainInput = getMainInput();
        if (mainInput == null)
        {
            return 0;
        }
        else
        {
            return mainInput.size();
        }
    }


    public boolean hasParameters ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
              throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return hasParameters(task, run);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error determining whether current task has parameters", error);
            return false;
        }
    }


    public Map<String, String> getSimpleParameters ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                return task.toolParameters();
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving current task's simple parameters", error);
            return null;
        }
    }


    public Map<String, List<TaskInputSourceDocument>> getParameterInput ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
              throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return getParameterInput(task, run);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving current task's file parameters", error);
            return null;
        }
    }


    public int getParameterCount ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
              throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return getParameterCount(task, run);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving current task's parameter count", error);
            return 0;
        }
    }


    public boolean hasOutput ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
              throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return hasOutput(task, run);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error determining whether current task has output", error);
            return false;
        }
    }


    public boolean hasWorkingDirectory ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                return hasWorkingDirectory(task);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error determining whether current task has working directory", error);
            return false;
        }
    }


    public List<FileHandler.FileAttributes> getWorkingDirectoryList ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                return getWorkingDirectoryList(task);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error getting list of files in working directory of current task.", error);
            return null;
        }
    }


    public Map<String, List<TaskOutputSourceDocument>> getOutput ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
              throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return getOutput(task, run);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving current task's output", error);
            return null;
        }
    }


    public int getOutputCount ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
              throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return getOutputCount(task, run);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving current task's output count", error);
            return 0;
        }
    }


    public String getCurrentTaskStageDivide()
    {
        String retStr = getCurrentTaskStage();
        if (retStr == null)
        {
          retStr = "NONE";
        }
        logger.info("retStr = " +  retStr);
        return  retStr;
    }

    public String getCurrentTaskStage ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                TaskRunStage stage = getRun(task, run).getStage();
                if (stage == null || stage.toString() == null)
                {
                    throw new NullPointerException("Current task has no stage.");
                }
                else
                {
                    String status = stage.toString();
                    if (stage.equals(TaskRunStage.SUBMITTED)) 
                    {
                      Statistics statistics = Statistics.find(task.getJobHandle(), run);
                      if (statistics.getDateStarted() != null)
                        status = status + " (running...)";
                      else
                        status = status + " (in waiting queue...)";
                    }
                    return status;
                }
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving execution stage of current task");
            return null;
        }
    }


    public boolean hasTaskMessages ()
    {
        try
        {
            Task task = getCurrentTask();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else
            {
                List<TaskLogMessage> messages = getLatestRun(task).logMessages();
                return (messages != null && messages.size() > 0);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error determining whether current task has messages");
            return false;
        }
    }

    public String getTaskMessagesDivide ()
    {
       List<TaskLogMessage> lists = getTaskMessages();

       StringBuilder sb = new StringBuilder();
       if (lists != null)
       {
         for (TaskLogMessage tl : lists)
         {
           sb.append(tl.toString());
           sb.append("<br>");
         }
       }
       return sb.toString();
    }


    public List<TaskLogMessage> getTaskMessages ()
    {
        try
        {
            Task task = getCurrentTask();
            Integer run = getCurrentRun();
            if (task == null)
            {
                throw new NullPointerException("No task is currently selected.");
            }
            else if (run == null)
            {
                throw new NullPointerException("No task run is currently selected.");
            }
            else
            {
                return getRun(task, run).logMessages();
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving current task's messages");
            return null;
        }
    }


    @Override
    public Page<? extends FolderItem> getCurrentPage ()
    {
        return getFolderTaskTabs().getCurrentTab().getContents();
    }


    @Override
    public void setPageSize ( Integer pageSize )
    {
        try
        {
            getController().
                    setUserPreference(TASK_PAGE_SIZE, pageSize.toString());
            TabbedPanel<Task> taskPanel = getFolderTaskTabs();
            if (taskPanel != null && pageSize != null)
            {
                for (Tab<Task> taskTab : taskPanel.getTabs().getAllElements())
                {
                    List<Task> taskList
                            = taskTab.getContents().getAllElements();
                    taskTab.setContents(
                            new ListPage<Task>(taskList, pageSize));
                }
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error saving user's selected task page size", error);
        }
        getCurrentPage().setPageSize(pageSize);
    }


    protected Task getSelectedTask ( Long taskId )
    {
        try
        {
            WorkbenchSession session = getWorkbenchSession();
            if (session == null)
            {
                throw new NullPointerException("No session is present.");
            }
            else
            {
                return session.findTask(taskId);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving selected task", error);
            return null;
        }
    }


    public TabbedPanel<Task> refreshFolderTaskTabs ()
    {
        try
        {
            Folder folder = getCurrentFolder();
            
            if (folder == null)
            {
                throw new NullPointerException("No folder is currently selected.");
            }
            else
            {
                //TODO: Add support for multiple task tab categories
                List<Task> taskList = folder.findTasks();
                
                getWorkbenchSession().sortTasks(taskList, TaskSortableField.ID, true);
                
                TabbedPanel<Task> folderTasks = null;
                
                if (taskList != null && !taskList.isEmpty())
                {
                    folderTasks = new TabbedPanel<Task>(folder);
                    
                    List<Tab<Task>> taskTabs = new Vector<Tab<Task>>(1);
                    
                    Page<Task> taskPage = new ListPage<Task>(taskList);
                    
                    Tab<Task> taskTab = new Tab<Task>(taskPage, "Tasks");
                    taskTabs.add(taskTab);
                    
                    folderTasks.setTabs(new ListPage<Tab<Task>>(taskTabs));
                    folderTasks.sortTabs();
                }
                
                setFolderTaskTabs(folderTasks);
                refreshFolders();
                return folderTasks;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving tabbed folder tasks", error);
            return null;
        }
    }


    protected void cancelTask ( Task task )
    {
        try
        {
            WorkbenchSession session = getWorkbenchSession();
            if (session == null)
            {
                throw new NullPointerException("No session is present.");
            }
            else if (task == null)
            {
                throw new NullPointerException("Task was not found.");
            }
            else
            {
                session.cancelTask(task);
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error cancelling task", error);
        }
    }


    protected boolean 
    deleteTask ( Task task )
    {
        try
        {
            WorkbenchSession wbSession = getWorkbenchSession();
            
            if (wbSession == null)
            {
                throw new NullPointerException("No session is present.");
            }
            else if (task == null)
            {
                throw new NullPointerException("Task was not found.");
            }
            else
            {
                final Long id = task.getTaskId();
                
                wbSession.deleteTask(task);
                
                task = wbSession.findTask(id); 
                
                if (task == null)
                {
                    return true;
                }
                
                return false;
            }
        }
        catch ( Throwable error )
        {
            logger.error("Error deleting task", error);
            return false;
        }
    }


    protected String getMainInputParameter ( String toolId )
    {
//        logger.info("BEGIN: getMainInputParameter(String)::String");
        
        String retVal = null; 
        
        if (toolId != null)
        {
            String inputParam = getConceptLabel("ToolInput", toolId);
            
            if (inputParam != null && inputParam.equals(toolId))
            {
                retVal = null;
            } 
            else 
            {
                retVal = inputParam;
            }
        }
        
//        logger.info("END: getMainInputParameter(String)::String");
        
        return retVal; 
    }


    public String getData ( SourceDocument document )
    {
        try
        {
            return getSourceDataAsString(document);
        }
        catch ( Throwable error )
        {
            logger.error("Error retrieving data from source document", error);
            return null;
        }
    }


    protected int moveSelectedTasks ()
    {
        // get IDs of selected tasks to move
        int moved = 0;
        Long[] selectedIds = getSelectedIds();
        if (selectedIds == null || selectedIds.length < 1)
        {
            return moved;
        }

        // get target folder to move to
        Folder folder = getFolderController().getFolder(getTargetFolder());
        if (folder == null)
        {
            addActionError("Error moving task to folder with ID "
                    + getTargetFolder() + ": folder not found.");
        }

        // move selected tasks to target folder
        else
        {
            for (int i = 0; i < selectedIds.length; i++)
            {
                Task task = getSelectedTask(selectedIds[i]);
                if (task == null)
                {
                    addActionError("Error moving task with ID "
                            + selectedIds[i] + ": item not found.");
                }
                else
                {
                    try
                    {
                        getWorkbenchSession().move(task, folder);
                        moved++;
                    }
                    catch ( Throwable error )
                    {
                        logger.error("Error moving task \"" + task.getLabel()
                                    + "\" to folder \"" + folder.getLabel() + "\"", error);
                    }
                }
            }
        }
        return moved;
    }


    /**
     * Updated by Mona to refresh user data size after deletion.
     *
     * @return
     */
    protected int deleteSelectedTasks ()
    {
        int deleted = 0;
        Long[] selectedIds = getSelectedIds();
        if (selectedIds == null || selectedIds.length < 1)
        {
            return deleted;
        }
        else
        {
            User user = null;

            for (int i = 0; i < selectedIds.length; i++)
            {
                Task task = getSelectedTask(selectedIds[i]);
                if (task == null)
                {
                    addActionError("Error deleting task with ID "
                            + selectedIds[i] + ": item not found.");
                }
                else
                {
                    try
                    {
                        if (deleteTask(task))
                        {
                            user = task.getUser();
                            deleted++;
                        }
                    }
                    catch ( Throwable error )
                    {
                        logger.error("Error deleting task \""
                                    + task.getLabel() + "\"", error);
                    }
                }
            }

            if (user != null)
            {
                clearActionErrors();
                refreshUserDataSize(user);
            }
        }
        return deleted;
    }


    protected int cancelSelectedTasks ()
    {
        int cancelled = 0;
        Long[] selectedIds = getSelectedIds();
        if (selectedIds == null || selectedIds.length < 1)
        {
            return cancelled;
        }
        else
        {
            for (int i = 0; i < selectedIds.length; i++)
            {
                Task task = getSelectedTask(selectedIds[i]);
                if (task == null)
                {
                    addActionError("Error cancelling task with ID "
                            + selectedIds[i] + ": item not found.");
                }
                else
                {
                    try
                    {
                        cancelTask(task);

                        cancelled++;
                    }
                    catch ( Throwable error )
                    {
                        logger.error("Error cancelling task \""
                                    + task.getLabel() + "\"", error);
                    }
                }
            }
        }
        return cancelled;
    }


    private TaskRun getRun ( Task task, int run )
    {
        try
        {
            WorkbenchSession session = getWorkbenchSession();

            if (session != null)
            {
                return session.getRun(task, run);
            }
            else
            {
                throw new NullPointerException("No session is present.");
            }
        }
        catch (IOException | SQLException err)
        {
            logger.error("Error fetching TaskRun", err);
            return null;
        }
    }


    private TaskRun getLatestRun ( Task task )
    {
    	try
    	{
    		return task.runs().last();
    	}
    	catch (IOException | SQLException err)
    	{
    		logger.error("Error fetching lastest TaskRun", err);

    		return null;
    	}
    }
}