/**
 * 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.krms.api.repository.NaturalLanguageTree;
import org.kuali.rice.krms.api.repository.RuleManagementService;
import org.kuali.rice.krms.api.repository.language.NaturalLanguageUsage;
import org.kuali.rice.krms.api.repository.proposition.PropositionDefinition;
import org.kuali.rice.krms.api.repository.proposition.PropositionParameter;
import org.kuali.rice.krms.api.repository.proposition.PropositionParameterContract;
import org.kuali.rice.krms.api.repository.proposition.PropositionParameterType;
import org.kuali.rice.krms.api.repository.term.TermDefinition;
import org.kuali.rice.krms.api.repository.term.TermParameterDefinition;
import org.kuali.rice.krms.dto.PropositionEditor;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;

/**
 * @author Kuali Student Team
 */
public class NaturalLanguageHelper {

    private RuleManagementService ruleManagementService;

    private Map<String, String> usageMap = new HashMap<String, String>();

    /**
     * This method should set the natural language only for the given proposition. It does not
     * do a recursive call through the tree structure.
     *
     * @param proposition
     * @param usageName
     */
    public void setNaturalLanguageForUsage(PropositionEditor proposition, String usageName, String namespace){
        //Setup the Proposition
        List<PropositionParameter.Builder> parameters = new ArrayList<PropositionParameter.Builder>();
        if(proposition.getParameters()!=null){  //Parameters on Compound Propositions could be null.
            for(PropositionParameterContract parameter : proposition.getParameters()){
                PropositionParameter.Builder parmBuilder = PropositionParameter.Builder.create(parameter);

                //Add the edited term.
                if(parameter.getParameterType().equals(PropositionParameterType.TERM.getCode())){
                    if(proposition.getTerm()!=null){
                        TermDefinition.Builder termBuilder = TermDefinition.Builder.create(proposition.getTerm());
                        for (Map.Entry<String, String> entry : proposition.getNlParameters().entrySet()) {
                            termBuilder.getParameters().add(TermParameterDefinition.Builder.create(null, null, entry.getKey(), entry.getValue()));
                        }
                        parmBuilder.setTermValue(termBuilder.build());
                    }
                }
                parameters.add(parmBuilder);
            }
        }

        //Create the propbuilder but don set compound editors here, we only want to get the nl for current proposition
        PropositionDefinition.Builder propBuilder = PropositionDefinition.Builder.create(proposition.getId(),
                proposition.getPropositionTypeCode(), proposition.getRuleId(), proposition.getTypeId(), parameters);

        //Build the tree.
        TreeIterator nlTree = this.buildNaturalLanguageTree(propBuilder, this.getNaturalLanguageUsageId(usageName, namespace));
        this.setTranslatedNaturalLanguage(proposition, usageName, nlTree);
    }

    /**
     * This method sets the natural language descriptions for the given proposition and all its child propositions as
     * well.
     *
     * @param proposition
     * @param usageName
     */
    public void setNaturalLanguageTreeForUsage(PropositionEditor proposition, String usageName, String namespace){
        if(proposition==null){
            return;
        }

        PropositionDefinition.Builder propBuilder = PropositionDefinition.Builder.create(proposition);
        TreeIterator nlTree = this.buildNaturalLanguageTree(propBuilder, this.getNaturalLanguageUsageId(usageName, namespace));
        this.setTranslatedNaturalLanguage(proposition, usageName, nlTree);
    }

    private TreeIterator buildNaturalLanguageTree(PropositionDefinition.Builder propBuilder, String usageId){
        NaturalLanguageTree nlTree = this.getRuleManagementService().translateNaturalLanguageTreeForProposition(usageId, propBuilder.build(), "en");
        return new TreeIterator(nlTree);
    }

    private void setTranslatedNaturalLanguage(PropositionEditor proposition, String usageName, TreeIterator nlDescriptions){
        if(!nlDescriptions.hasNext()){
            return;
        }

        proposition.setNaturalLanguageForUsage(usageName, nlDescriptions.next());

        if (proposition.getCompoundEditors() != null){
            for (PropositionEditor child : proposition.getCompoundEditors()){
                setTranslatedNaturalLanguage(child, usageName, nlDescriptions);
            }
        }
    }

    private String getNaturalLanguageUsageId(String usageName, String namespace){
        //usageName cannot be null or blank
        if ((usageName == null) || (StringUtils.isBlank(usageName))){
            return null;
        }

        //Retrieve usageId form map.
        String usageId = usageMap.get(usageName);
        if (usageId == null){

            //Retrieve usage from service if usageId not on map.
            NaturalLanguageUsage usage = this.getRuleManagementService().getNaturalLanguageUsageByNameAndNamespace(usageName,
                    namespace);

            //Set the usage id to the map.
            if (usage != null){
                usageId = usage.getId();
                usageMap.put(usageName, usageId);
            }
        }
        return usageId;
    }

    public RuleManagementService getRuleManagementService() {
        return ruleManagementService;
    }

    public void setRuleManagementService(RuleManagementService ruleManagementService) {
        this.ruleManagementService = ruleManagementService;
    }

    /**
     * Put the natural language descriptions in a queue and retrieve them in
     * the same order as the propostion tree.
     */
    protected class TreeIterator implements Serializable, Iterator<String> {

        private Queue<String> nl;

        public TreeIterator(NaturalLanguageTree tree){
            nl = new LinkedList<String>();
            this.addToStack(tree);
        }

        private void addToStack(NaturalLanguageTree tree){
            if (tree == null){
                return;
            }

            nl.offer(tree.getNaturalLanguage());
            if (tree.getChildren() != null){
                for (NaturalLanguageTree child : tree.getChildren()){
                    addToStack(child);
                }
            }
        }

        @Override
        public boolean hasNext() {
            return !nl.isEmpty();
        }

        @Override
        public String next() {
            return nl.poll();
        }

        @Override
        public void remove() {
            //To change body of implemented methods use File | Settings | File Templates.
        }
    }
}