package org.ngbw.web.actions;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

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

import org.ngbw.sdk.WorkbenchSession;
import org.ngbw.sdk.api.tool.ParameterValidator;
import org.ngbw.sdk.database.SourceDocument;
import org.ngbw.sdk.database.Task;
import org.ngbw.sdk.database.TaskInputSourceDocument;
import org.ngbw.sdk.database.UserDataItem;


/**
 *
 * @author Tony Chen
 */
@SuppressWarnings("serial")
public abstract class ToolParameters extends CreateTask
{
    private static final Logger logger = Logger.getLogger(ToolParameters.class.getName());
    

    // all parameters will be stored in a single generic map.  
    private Map<String, String> toolParameters;

    private Map<String, String> uiParameters;

    private Map<String, List<TaskInputSourceDocument>> inputDataItems;

    private String disabledFields;


    public String getDisabledFields__ ()
    {
        return disabledFields;
    }


    public void setDisabledFields__ ( String s )
    {
        logger.debug("BEGIN: setDisabledFields__(String)::void");
        
        disabledFields = s;
        
        logger.debug("END: setDisabledFields__(String)::void");
    }


    /*
     * ================================================================
     * Constructors
     * ================================================================
     */
    public ToolParameters ()
    {
        super();
        setTab(SET_PARAMETERS_TAB_LBL);
    }


    private void removeDisabledFields ( Map<String, String> params, String disabled )
    {
        logger.debug("BEGIN: removeDisabledFields(Map<String, String>, String)::void");
        
        if (disabled != null)
        {
            String[] disabledKeys = disabled.split(",");
            
            for (String dkey : disabledKeys)
            {
                if (params.containsKey(dkey.trim()))
                {
                    params.remove(dkey.trim());
                }
            }
        }
        
        logger.debug("END: removeDisabledFields(Map<String, String>, String)::void");
    }


    /*
     * ================================================================
     * Action methods
     * ================================================================
     */
    @SuppressWarnings("unchecked")
    @Override
    public String execute ()
    {
        try
        {
            logger.debug("disabled field list is " + getDisabledFields__());
            removeDisabledFields(toolParameters, getDisabledFields__());

            // validate parameters
            boolean error = false;
            Task task = getCurrentTask();
            ParameterValidator validator = getParameterValidator(task.getToolId());

            /*
             * logger.debug("After we remove disabled params, we have:");
             * for (String name : toolParameters.keySet())
             * {
             * logger.debug(name + "=" + toolParameters.get(name));
             * }
             */

 /*
             * logger.debug("These are ALL the request parameters (with string keys) that we
             * received.");
             * Map pmap = getParameters();
             * for (Object obj : pmap.keySet())
             * {
             * if (!(obj instanceof String))
             * {
             * continue;
             * }
             * String value = getRequestParameter((String)obj);
             * logger.debug((String)obj + "='" + value + "'");
             * }
             */
            Map<String, String> errors = validator.validateParameters(toolParameters);
            
            if (errors != null && errors.size() > 0)
            {
                for (String parameter : errors.keySet())
                {
                    addActionError(errors.get(parameter));
                }
                
                error = true;
            }
            
            errors = validator.validateInput(getInputDataItems());
            
            if (errors != null && errors.size() > 0)
            {
                for (String parameter : errors.keySet())
                {
                    addActionError(errors.get(parameter));
                }
                
                error = true;
            }

            // return to input page if validation failed
            if (error)
            {
                setTab(SET_PARAMETERS_TAB_LBL);
                return INPUT;
            }

            // set toolParameters into task
            setParameters(task, cleanParameters());

            setInputMap(cleanInput());
            List<TaskInputSourceDocument> input = getInput();
            
            if (input != null)
            {
                setInput(input);
            }

            // report number of parameters successfully set
            int parameterCount = getParameterCount();
            String message = parameterCount + " parameter";
            
            if (parameterCount != 1)
            {
                message += "s";
            }
            
            message += " successfully set to current task.";
            logger.debug(super.reportUserMessage(message));
            setTab(TASK_SUMMARY_TAB_LBL);

            // Let CreateTask know that the tool gui was opened and parameters were saved.
            logger.debug("Adding TOOL_GUI_OPENED");
            task.toolParameters().put(TOOL_GUI_OPENED, "1");

            return SUCCESS;
        }
        catch ( Throwable e )
        {
            logger.error(reportUserError(e, "Internal Error."));
            return INPUT;
        }
    }


    /**
     * I think this is called anytime we display the tool GUI page.
     * It puts initial values in uiParameters map. The generated action classes
     * have getter methods that return the values from uiParameters so they'll be
     * displayed in the form.
     * <p>
     * generated action classes inherit from ToolParameters and are:
     * pise2JavaSimple.ftl, pise2JavaAdvanced.ftl ->
     * build/portal/src/main/java/org/ngbw/web/actions/tool/<tool>.java
     * 
     * @return 
     */
    @SkipValidation
    @Override
    public String input ()
    {
        logger.info("BEGIN: input()::String");
        
        // If the task has parameters, put them in uiParameters to be displayed as initial values. 
        if (hasParameters())
        {
            try
            {
                setUIParameters(getCurrentTask().toolParameters());
            }
            catch ( Throwable error )
            {
                logger.error(constructMessage(error, "Error retrieving parameters from current task"));
            }
            
            setInputDataItems(getInputMap());
            
            Map<String, List<TaskInputSourceDocument>> inputDataItems = getInputDataItems();
            
            if (inputDataItems != null && inputDataItems.size() > 0)
            {
                for (String parameter : inputDataItems.keySet())
                {
                    verifyInputDataItem(parameter);
                }
            }
        }
        else
        {
            // If task doesn't already have parameters, this puts an entry in uiParameters for each parameter that has a vdef.
            reset();
        }
        
        logger.info("END: input()::String");
        
        return INPUT;
    }


    @SkipValidation
    @Override
    public String cancel ()
    {
        logger.debug("BEGIN: cancel()::String");
        clearErrorsAndMessages();
        addActionMessage("Task parameters not saved.");
        setTab(TASK_SUMMARY_TAB_LBL);
        logger.debug("END: cancel()::String");
        return INPUT;
    }


    @SkipValidation
    public String resetPage ()
    {
        reset();
        setTab(SET_PARAMETERS_TAB_LBL);
        return INPUT;
    }


    /*
     * ================================================================
     * Tool parameter property accessor methods
     * ================================================================
     */
    protected void setToolParameter ( String name, String value )
    {
        getToolParameters().put(name, value);
    }


    private Map<String, String> getToolParameters ()
    {
        if (toolParameters == null)
        {
            resetParameters();
        }
        
        return toolParameters;
    }


    protected Map<String, String> getUIParameters ()
    {
        if (uiParameters == null)
        {
            resetParameters();
        }
        
        return uiParameters;
    }


    private void setUIParameters ( Map<String, String> parameters )
    {
        if (parameters != null)
        {
            this.uiParameters = parameters;
        }
        else
        {
            resetParameters();
        }
    }


    public Map<String, List<TaskInputSourceDocument>> getInputDataItems ()
    {
        if (inputDataItems == null)
        {
            resetInput();
        }
        
        return inputDataItems;
    }


    public void setInputDataItems ( Map<String, List<TaskInputSourceDocument>> inputDataItems )
    {
        if (inputDataItems != null)
        {
            this.inputDataItems = inputDataItems;
        }
        else
        {
            resetInput();
        }
    }


    /**
     * This implementation assumes that each "non-main" input parameter has only one
     * SourceDocument in its map, and this value is keyed by the database ID of the
     * single UserDataItem that spawned it.
     *
     * If this UserDataItem no longer exists in the database for whatever reason,
     * then searching for it by the ID map key will return null, and this will indicate
     * that it is no longer attached to a persisted data item.
     * 
     * @param parameter
     * 
     * @return 
     */
    public Long getInputDataItemId ( String parameter )
    {
        logger.debug("BEGIN: getInputDataItemId(String)::Long");
        
        Long retVal = null; 
        
        try
        {
            Map<String, List<TaskInputSourceDocument>> inputItems = getInputDataItems();
            
            if (parameter == null)
            {
                throw new NullPointerException("Parameter key is null.");
            }
            else if (inputItems == null)
            {
                throw new NullPointerException("No input parameter map is present.");
            }
            else
            {
                List<TaskInputSourceDocument> parameterData = inputItems.get(parameter);
                
                if (parameterData == null || parameterData.isEmpty())
                {
                    retVal = null;
                }
                else
                {
                    String id = parameterData.get(0).getName();
                    retVal = Long.parseLong(id);
                }
            }
        }
        catch ( Throwable error )
        {
            logger.error(super.constructMessage(error, "Error retrieving user selection for input parameter"));
            retVal = null;
        }
        
        logger.debug("END: getInputDataItemId(String)::Long");
        
        return retVal; 
    }


    public void setInputDataItem ( String parameter, Long dataId )
    {
        logger.debug("BEGIN: setInputDataItem(String, Long)::void");
        
        try
        {
            Map<String, List<TaskInputSourceDocument>> inputItems = getInputDataItems();
            
            if (parameter == null)
            {
                throw new NullPointerException("Parameter key is null.");
            }
            else if (inputItems == null)
            {
                throw new NullPointerException("No input parameter map is present.");
            }
            else if (dataId == null)
            {
                inputItems.remove(parameter);
            }
            else
            {
                WorkbenchSession session = getWorkbenchSession();
        
                if (session == null)
                {
                    throw new NullPointerException("No session is present.");
                }
                else
                {
                    UserDataItem dataItem = session.findUserDataItem(dataId);
                
                    if (dataItem == null || dataItem.isNew())
                    {
                        throw new NullPointerException("Selected data item is "
                                + "not present in the database.");
                    }
                    else
                    {
                        // We have a dataItem = a userDataItem
                        SourceDocument srcDocument = session.getSourceDocument(dataItem);
                        
                        if (srcDocument == null)
                        {
                            throw new NullPointerException("Selected data item has " + "no source document.");
                        }
                        else
                        {
                            List<TaskInputSourceDocument> input = new ArrayList<TaskInputSourceDocument>(1);
                            TaskInputSourceDocument inputDocument = new TaskInputSourceDocument(srcDocument);
                            inputDocument.setName(Long.toString(dataItem.getUserDataId()));
                            input.add(inputDocument);
                            inputItems.put(parameter, input);
                            setInputDataItems(inputItems);
                        }
                    }
                }
            }
        }
        catch ( Throwable error )
        {
            logger.error(super.constructMessage(error, "Error setting data as input parameter"));
        }
        
        logger.debug("END: setInputDataItem(String, Long)::void");
    }

    
    // This is called by generated tool form actions and CreateTask.java.
    public void reset ()
    {
        logger.debug("BEGIN: reset()::void");
        resetParameters();
        resetInput();
        logger.debug("END: reset()::void");
    }


    /*
     * ================================================================
     * Parameter selection page property accessor methods
     * ================================================================
     */
    public Map<Long, String> getDataForParameter ( String parameter )
    {
        logger.debug("BEGIN: getDataForParameter(String)::Map<Long, String>");
        
        Map<Long, String> retVal = null; 
        
        String tool = getToolId();
        
        if (tool == null || parameter == null)
        {
            retVal = null;
        }
        else
        {
            try
            {
                //TODO: need getDataForParameter() business method
                List<UserDataItem> dataList = getCurrentFolder().findDataItems();
                
                if (dataList != null && !dataList.isEmpty())
                {
                    Map<Long, String> dataMap = new HashMap<Long, String>(dataList.size());

                    for (UserDataItem dataItem : dataList)
                    {
                        dataMap.put(dataItem.getUserDataId(), truncateText(dataItem.getLabel()));
                    }

                    retVal = dataMap;
                }
            }
            catch ( Throwable error )
            {
                logger.error(super.constructMessage(error, "Error retrieving current folder's data list"));
                retVal = null;
            }
        }
        
        logger.debug("END: getDataForParameter(String)::Map<Long, String>");
        
        return retVal;
    }


    /*
     * ================================================================
     * Convenience methods
     * ================================================================
     */
    protected void resetParameters ()
    {
        if (toolParameters == null)
        {
            toolParameters = new HashMap<>();
        }

        if (uiParameters == null)
        {
            uiParameters = new HashMap<>();
        }

        toolParameters.clear();
        logger.debug("Tool parameters, Map<String, String>, cleared!");
        
        uiParameters.clear();
        logger.debug("UI parameters, Map<String, String>, cleared!");
    }


    protected void resetInput ()
    {
        if (inputDataItems == null)
        {
            inputDataItems = new HashMap<>();
        }
        
        inputDataItems.clear();
        logger.debug("InputDataItems, Map<String, List<TaskInputSourceDocument>>, cleared!");
    }


    protected Map<String, String> cleanParameters ()
    {
        logger.debug("BEGIN: cleanParameters()::Map<String, String>");
        
        Map<String, String> retVal = null; 
        
        if (toolParameters == null)
        {
            retVal = null;
        }
        else
        {
            List<String> emptyParameters = new ArrayList<>();
            //logger.debug("Form submitted with these parameters:");
            
            for (String parameter : toolParameters.keySet())
            {
                String value = toolParameters.get(parameter);
                
                if (value == null || value.trim().isEmpty())
                {
                    emptyParameters.add(parameter);
                }
                else
                {
                    //logger.debug(parameter + "='" + value + "'");
                }
            }
            //logger.debug("Removing these empty parameters:");
            for (String emptyParameter : emptyParameters)
            {
                toolParameters.remove(emptyParameter);
                //logger.debug("Remove " + emptyParameter);
            }
            
            retVal = toolParameters;
        }
        
        logger.debug("END: cleanParameters()::Map<String, String>");
        
        return retVal; 
    }


    protected Map<String, List<TaskInputSourceDocument>> cleanInput ()
    {
        logger.debug("BEGIN: cleanInput()::Map<String, List<TaskInputSourceDocument>>");
        
        Map<String, List<TaskInputSourceDocument>> retVal = null; 
        
        if (inputDataItems == null)
        {
            retVal = null;
        }
        else
        {
            List<String> emptyParameters = new ArrayList<>();
            
            for (String parameter : inputDataItems.keySet())
            {
                List<TaskInputSourceDocument> value = inputDataItems.get(parameter);
                
                if (value == null || value.size() < 1)
                {
                    emptyParameters.add(parameter);
                }
            }
            
            for (String emptyParameter : emptyParameters)
            {
                toolParameters.remove(emptyParameter);
            }
            
            retVal = inputDataItems; 
        }
        
        logger.debug("END: cleanInput()::Map<String, List<TaskInputSourceDocument>>");
        
        return retVal; 
    }


    protected void verifyInputDataItem ( String parameter )
    {
        logger.debug("BEGIN: verifyInputDataItem(String)::void");
        
        try
        {
            Map<String, List<TaskInputSourceDocument>> inputItems = getInputDataItems();
            
            if (parameter == null)
            {
                throw new NullPointerException("Parameter key is null.");
            }
            else if (inputItems == null)
            {
                throw new NullPointerException("No input parameter map is present.");
            }
            else
            {
                List<TaskInputSourceDocument> parameterData = inputItems.get(parameter);
                
                if (parameterData == null || parameterData.isEmpty())
                {
                    throw new NullPointerException("Parameter \""
                            + parameter + "\" is not present in the input "
                            + "parameter map.");
                }
                else
                {
                    String id = parameterData.get(0).getName();
                    Long dataId = Long.parseLong(id);
                    
                    boolean found = false;
                    
                    if (dataId != null)
                    {
                        for (UserDataItem dataItem : getCurrentFolder().findDataItems())
                        {
                            if (dataId.equals(dataItem.getUserDataId()))
                            {
                                found = true;
                                break;
                            }
                        }
                    }
                    
                    if (!found)
                    {
                        logger.error(reportUserError("Warning: Parameter \""
                                + parameter + "\" must be re-selected, because "
                                + "the data item previously assigned to it "
                                + "is no longer present in the current folder."));
                    }
                }
            }
        }
        catch ( NullPointerException error )
        {
            logger.error(constructMessage(error, "Error verifying persistence of input parameter"));
        }
        catch ( Throwable error )
        {
            logger.error(constructMessage(error, "Error verifying persistence of input parameter"));
        }
        
        logger.debug("END: verifyInputDataItem(String)::void");
    }

}