/**
 * Copyright 2005-2013 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.krms.util;

import org.apache.commons.lang.StringUtils;
import org.kuali.rice.core.api.util.tree.Node;
import org.kuali.rice.krms.api.repository.LogicalOperator;
import org.kuali.rice.krms.api.repository.proposition.PropositionParameterType;
import org.kuali.rice.krms.api.repository.proposition.PropositionType;
import org.kuali.rice.krms.dto.PropositionEditor;
import org.kuali.rice.krms.dto.PropositionParameterEditor;
import org.kuali.rice.krms.dto.RuleEditor;
import org.kuali.rice.krms.tree.node.RuleEditorTreeNode;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Utility class with common functionality on the proposition tree.
 *
 * @author Kuali Student Team
 */
public class PropositionTreeUtil {

    public static final String DOC_NEW_DATAOBJECT_PATH = "document.newMaintainableObject.dataObject";
    public static final String EDIT_TREE_NEW_COLLECTION_LINE = DOC_NEW_DATAOBJECT_PATH + ".editTree";

    public static String getBindingPath(PropositionEditor proposition, String propertyName) {
        return getBindingPrefix(proposition) + "proposition." + propertyName;
    }

    public static String getBindingPrefix(PropositionEditor proposition) {
        return DOC_NEW_DATAOBJECT_PATH + "." + proposition.getBindingPath() + ".";
    }

    public static Node<RuleEditorTreeNode, String> findParentPropositionNode(Node<RuleEditorTreeNode, String> currentNode, String selectedPropKey) {
        Node<RuleEditorTreeNode, String> bingo = null;
        if (selectedPropKey != null) {
            // if it's in children, we have the parent
            List<Node<RuleEditorTreeNode, String>> children = currentNode.getChildren();
            for (Node<RuleEditorTreeNode, String> child : children) {
                RuleEditorTreeNode dataNode = child.getData();
                if (selectedPropKey.equalsIgnoreCase(dataNode.getProposition().getKey())) {
                    return currentNode;
                }
            }

            // if not found check grandchildren
            for (Node<RuleEditorTreeNode, String> kid : children) {
                bingo = findParentPropositionNode(kid, selectedPropKey);
                if (bingo != null) {
                    break;
                }
            }
        }
        return bingo;
    }

    /**
     * @return the {@link org.kuali.rice.krms.impl.repository.PropositionBo} from the form
     */
    public static PropositionEditor getProposition(RuleEditor ruleEditor) {

        if (ruleEditor != null) {
            String selectedPropKey = ruleEditor.getSelectedKey();
            return findProposition(ruleEditor.getEditTree().getRootElement(), selectedPropKey);
        }

        return null;
    }

    public static PropositionEditor findProposition(Node<RuleEditorTreeNode, String> currentNode, String selectedPropKey) {

        if ((selectedPropKey == null) || (selectedPropKey.isEmpty())) {
            return null;
        }

        // if it's in children, we have the parent
        for (Node<RuleEditorTreeNode, String> child : currentNode.getChildren()) {
            PropositionEditor proposition = child.getData().getProposition();
            if (selectedPropKey.equalsIgnoreCase(proposition.getKey())) {
                return proposition;
            } else if ("S".equals(proposition.getPropositionTypeCode()) && proposition.isEditMode()) {
                return proposition;
            } else if (!proposition.isEditMode()) {
                // if not found check grandchildren
                proposition = findProposition(child, selectedPropKey);
                if (proposition != null) {
                    return proposition;
                }
            }
        }

        return null;
    }

    /**
     * Find and return the node containing the proposition that is in currently in edit mode
     *
     * @param node the node to start searching from (typically the root)
     * @return the node that is currently being edited, if any.  Otherwise, null.
     */
    public static Node<RuleEditorTreeNode, String> findEditedProposition(Node<RuleEditorTreeNode, String> node) {
        Node<RuleEditorTreeNode, String> result = null;
        if (node.getData() != null && node.getData().getProposition() != null && node.getData().getProposition()
                .isEditMode()) {
            result = node;
        } else {
            for (Node<RuleEditorTreeNode, String> child : node.getChildren()) {
                result = findEditedProposition(child);
                if (result != null) {
                    break;
                }
            }
        }
        return result;
    }

    /**
     * disable edit mode for all Nodes beneath and including the passed in Node
     *
     * @param proposition
     */
    public static boolean resetEditModeOnPropositionTree(PropositionEditor proposition) {
        if(proposition==null){
            return false;
        }

        boolean editMode = proposition.isEditMode();
        proposition.setEditMode(false);
        if (proposition.getCompoundEditors() != null) {
            for (PropositionEditor childProp : proposition.getCompoundEditors()) {
                if(resetEditModeOnPropositionTree(childProp)) {
                    editMode = true;
                }
            }
        }
        return editMode;
    }

    /**
     * Builds a logical string expression from the proposition tree.
     *
     * @param proposition
     * @return
     */
    public static String configureLogicExpression(PropositionEditor proposition) {
        // If the prop is a compound proposition, calls itself for each of the compoundComponents
        if (PropositionType.COMPOUND.getCode().equalsIgnoreCase(proposition.getPropositionTypeCode())) {
            StringBuilder logicExpression = new StringBuilder();
            boolean first = true;
            for (PropositionEditor child : proposition.getCompoundEditors()) {
                // add an opcode node in between each of the children.
                if (!first) {
                    logicExpression.append(" " + getLabelForOperator(proposition.getCompoundOpCode()) + " ");
                }
                first = false;
                // call to build the childs node
                String compoundExpression = configureLogicExpression(child);
                if (compoundExpression.length() > 1) {
                    logicExpression.append("(" + compoundExpression + ")");
                } else {
                    logicExpression.append(compoundExpression);
                }
            }
            return logicExpression.toString();
        } else {
            return proposition.getKey();
        }
    }

    /**
     * This method creates a partially populated Simple PropositionBo with
     * three parameters:  a term type paramter (value not assigned)
     * a operation parameter
     * a constant parameter (value set to empty string)
     * The returned PropositionBo has an generatedId. The type code and ruleId properties are assigned the
     * same value as the sibling param passed in.
     * Each PropositionParameter has the id generated, and type, sequenceNumber,
     * propId default values set. The value is set to "".
     *
     * @param sibling -
     * @return a PropositionBo partially populated.
     */
    public static PropositionEditor createSimplePropositionBoStub(PropositionEditor sibling, Class<? extends PropositionEditor> propClass) throws IllegalAccessException, InstantiationException {
        // create a simple proposition Bo
        PropositionEditor prop = propClass.newInstance();
        prop.setPropositionTypeCode(PropositionType.SIMPLE.getCode());
        prop.setNewProp(true);
        prop.setEditMode(true);
        if (sibling != null) {
            prop.setRuleId(sibling.getRuleId());
        }

        prop.setParameters(createParameterList());

        return prop;
    }

    public static List<PropositionParameterEditor> createParameterList() {
        // create blank proposition parameters
        PropositionParameterEditor pTerm = new PropositionParameterEditor(PropositionParameterType.TERM.getCode(), Integer.valueOf("0"));
        PropositionParameterEditor pOp = new PropositionParameterEditor(PropositionParameterType.OPERATOR.getCode(), Integer.valueOf("2"));
        PropositionParameterEditor pConst = new PropositionParameterEditor(PropositionParameterType.CONSTANT.getCode(), Integer.valueOf("1"));

        return Arrays.asList(pTerm, pConst, pOp);
    }

    public static PropositionEditor createCompoundPropositionBoStub(PropositionEditor existing, boolean addNewChild, Class<? extends PropositionEditor> propClass) throws InstantiationException, IllegalAccessException {
        // create a simple proposition Bo
        PropositionEditor prop = createCompoundPropositionBoStub(existing, propClass);

        if (addNewChild) {
            PropositionEditor newProp = createSimplePropositionBoStub(existing, propClass);
            prop.getCompoundEditors().add(newProp);
            prop.setEditMode(false); // set the parent edit mode back to null or we end up with 2 props in edit mode
        }

        return prop;
    }

    public static PropositionEditor createCompoundPropositionBoStub(PropositionEditor existing, Class<? extends PropositionEditor> propClass) throws IllegalAccessException, InstantiationException {
        // create a simple proposition Bo
        PropositionEditor prop = propClass.newInstance();
        prop.setNewProp(true);
        prop.setPropositionTypeCode(PropositionType.COMPOUND.getCode());
        prop.setRuleId(existing.getRuleId());
        prop.setEditMode(false);

        List<PropositionEditor> components = new ArrayList<PropositionEditor>();
        components.add(existing);
        prop.setCompoundEditors(components);
        return prop;
    }

    public static void cancelNewProp(PropositionEditor proposition) {
        int i = 0;
        if (proposition.getCompoundEditors() != null) {
            while (i < proposition.getCompoundEditors().size()) {
                PropositionEditor child = proposition.getCompoundEditors().get(i);
                if (child.isNewProp() && child.isEditMode()) {
                    proposition.getCompoundEditors().remove(child);
                    continue;
                } else {
                    cancelNewProp(child);
                }
                i++;
            }
        }
    }

    /**
     * This method walks through the proposition tree including the root node on the tree
     * and remove all parent compounde propositions that only have one child.
     *
     * @param rule
     */
    public static void removeCompoundProp(RuleEditor rule) {
        //Check if the root only has one child, if so set the child as the root proposition.
        PropositionEditor root = rule.getPropositionEditor();
        if(root.getCompoundEditors().size() == 1) {
            rule.setProposition(root.getCompoundEditors().get(0));
        }

        //Remove single parent from proposition tree.
        removeCompoundProp(rule.getPropositionEditor());

    }

    /**
     * This method walks through the proposition tree and remove all parent compound propositions
     * that only have one child.
     *
     * Note: This does not handle the root as the root need to be set on the rule.
     *
     * @param proposition
     */
    public static void removeCompoundProp(PropositionEditor proposition){
        if (proposition.getCompoundEditors() != null) {

            // Handle the scenario if the inpust proposition only have one child.
            if(proposition.getCompoundEditors().size()==1){
                PropositionEditor child = proposition.getCompoundEditors().get(0);
                if(PropositionType.COMPOUND.getCode().equalsIgnoreCase(child.getPropositionTypeCode())) {
                    proposition.setCompoundEditors(child.getCompoundEditors());
                }
            }

            // Now handle the children.
            for(int i=proposition.getCompoundEditors().size()-1;i>=0;i--){
                PropositionEditor child = proposition.getCompoundEditors().get(i);
                if(PropositionType.COMPOUND.getCode().equalsIgnoreCase(child.getPropositionTypeCode())) {
                    if (child.getCompoundEditors().isEmpty()) {
                        proposition.getCompoundEditors().remove(i);
                    } else {
                        if (child.getCompoundEditors().size() == 1) {
                            proposition.getCompoundEditors().set(i, child.getCompoundEditors().get(0));
                        }
                        removeCompoundProp(child);
                    }
                }
            }
        }
    }

    public static void resetNewProp(PropositionEditor proposition) {
        proposition.setNewProp(false);
        if (proposition.getCompoundEditors() != null) {
            for (PropositionEditor child : proposition.getCompoundEditors()) {
                resetNewProp(child);
            }
        }
    }

    /**
     * Returns the first parameter of type term in the list.
     *
     * @param parameters
     * @return
     */
    public static PropositionParameterEditor getTermParameter(List<PropositionParameterEditor> parameters) {
        return getParameterForType(parameters, PropositionParameterType.TERM);
    }

    /**
     * Returns the first parameter of type constant in the list.
     *
     * @param parameters
     * @return
     */
    public static PropositionParameterEditor getConstantParameter(List<PropositionParameterEditor> parameters) {
        return getParameterForType(parameters, PropositionParameterType.CONSTANT);
    }

    /**
     * Returns the first parameter of type operator in the list.
     *
     * @param parameters
     * @return
     */
    public static PropositionParameterEditor getOperatorParameter(List<PropositionParameterEditor> parameters) {
        return getParameterForType(parameters, PropositionParameterType.OPERATOR);
    }

    /**
     * Returns the first parameter of the given type in the list.
     *
     * @param parameters
     * @param type
     * @return
     */
    public static PropositionParameterEditor getParameterForType(List<PropositionParameterEditor> parameters, PropositionParameterType type) {

        if (parameters == null) {
            return null;
        }

        for (PropositionParameterEditor parameter : parameters) {
            if (type.getCode().equals(parameter.getParameterType())) {
                return parameter;
            }
        }
        return null;
    }

    /**
     * Returns a label based on the operator code.
     *
     * @param opCode
     * @return
     */
    public static String getLabelForOperator(String opCode) {
        if (LogicalOperator.AND.getCode().equalsIgnoreCase(opCode)) {
            return "AND";
        } else if (LogicalOperator.OR.getCode().equalsIgnoreCase(opCode)) {
            return "OR";
        }
        return StringUtils.EMPTY;
    }

    public static boolean isSimpleCompounds(PropositionEditor propositionEditor) {
        for (int index = 0; index < propositionEditor.getCompoundEditors().size(); index++) {
            if (propositionEditor.getCompoundEditors().get(index).getPropositionTypeCode().equals("C")) {
                return false;
            }
        }
        return true;
    }
}