/*
 * FormulaFunction_Left.java
 *
 * Created on May 1, 2006, 9:46 AM
 *
 * Copyright 2006 Lee Lofgern and Accounting Enhancements Inc Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0 
 * 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 com.accountingenhancements.formula;

import com.accountingenhancements.common.SupportParameters;
import java.text.ParseException;
import java.util.HashMap;

/**
 *
 *  @author Lee lofgren lofgren_opensource@accountingenhancements.com
 * @version 0.1009102006
 */
public class FormulaFunction_Left extends FormulaFunction{
    
     protected static String[][] requiredArguments = {{"ARG1: The source String from which the left side is to be returned","TYPE_?"},{"ARG2: The size of result to return. If the source is less than this size, then the source size will be returned","TYPE_LONG"}};
     protected static String[] returnValueDescription = {"Left portion of ARG1, the size of which is no greater than specified in ARG2","TYPE_STRING"};
    /**
     *Create a new FormulaFunction with an already defined functionArgumentStack.
     *@param functionArgumentStack a list of <code>FormulaVariable</code>s that are needed by the function.
     */
    public FormulaFunction_Left(FormulaVariableStack functionArgumentStack){
        super(functionArgumentStack);
    }
    
    /**
     *Create a new FormulaFunction with a comma-delimited string representing the arguments needed by the function
     *@param functionArgumentString the string representing the functions arguments. The outer parentheses must be removed.<br/>
     *Example: If the function is IIF(A<B,"true","false") then functionArgumentString is A<B,"true","false".
     *@throws ParseException if arguments can't be parsed using parseCommaDelimitedFunctionFields(String,int)
     */
    public FormulaFunction_Left(String functionArgumentString) throws ParseException{
        super(functionArgumentString);
    }
    
    /**
     *Create a new FormulaFunction with a comma-delimited string representing the arguments needed by the function
     *@param functionArgumentString the string representing the functions arguments. The outer parentheses must be removed.<br/>
     *Example: If the function is IIF(A<B,"true","false") then functionArgumentString is A<B,"true","false".
     *@param level the level applied to the creation of FormulaVariables for the arguments.
     *@throws ParseException if arguments can't be parsed using parseCommaDelimitedFunctionFields(String,int)
     */
    public FormulaFunction_Left(String functionArgumentString, int level) throws ParseException{
        super(functionArgumentString,level);
    }
    
    /**
     *Create a new FormulaFunction from the functionVariable (A FormulaVariable of TYPE_FUNCTION).<br/>
     *This is the most common constructor used.
     *@param functionVariable a FormulaVariable of TYPE_FUNCTION
     *@throws ParseException if arguments can't be parsed using parseCommaDelimitedFunctionFields(String,int)
     */
    public FormulaFunction_Left(FormulaVariable functionVariable) throws ParseException{
        super(functionVariable);
        
    }

    protected FormulaVariable solve(FormulaVariableList variableList, int iteration, SupportParameters supportParameters, FormulaFunctionList functionList, int resolveEverythingAboveLevel) throws java.text.ParseException, java.lang.ArithmeticException, ClassNotFoundException{
        FormulaVariable result=null;
        String resultString;
        FormulaVariable sizeVariable;
        int highestLevel;
        int size=0;
        if(functionArgumentStack==null)throw new java.lang.ArithmeticException("functionArgumentStack is null");
        result=functionArgumentStack.get("ARG1");
        if(result==null)throw new java.lang.ArithmeticException("ARG1 is missing from functionArgumentStack");
        result=result.solve(variableList,iteration,supportParameters,functionList,resolveEverythingAboveLevel);
        if(result!=null){
            resultString=result.getString();
            highestLevel=result.getHighestLevel();
            if(resultString!=null){
                sizeVariable=functionArgumentStack.get("ARG2");
                if(sizeVariable==null)throw new java.lang.ArithmeticException("ARG2 is missing from functionArgumentStack");
                sizeVariable=sizeVariable.solve(variableList,iteration,supportParameters,functionList,resolveEverythingAboveLevel);
                if(sizeVariable!=null){
                    size=sizeVariable.getLong().intValue();
                    if(highestLevel<sizeVariable.getHighestLevel())highestLevel=sizeVariable.getHighestLevel();
                }
                if(size<0)size=0;
                if(resultString.length()>size){
                    result = new FormulaVariable("",resultString.substring(0,size),FormulaVariable.TYPE_STRING,0,highestLevel);
                }
            }
            if(highestLevel>result.getHighestLevel()){
                result=result.clone(); //Chances are that if this is true then the result is the original FormulaVariable and we want to leave that alone
                result.setHighestLevel(highestLevel);
            }
        }
        return result;
    }
    
    /**
     *@return the name of this function
     */
    public static String getName() {
        return "Left";
    }
    
    /**
     *@return String[][] of needed arguments and their dataTypes which as {{"Test Argument ARG1","TYPE_BOOLEAN"},{"True Argument ARG2","TYPE_?"},{"False Argument ARG3","TYPE_?"}}<br/>
     *If handing this routine a FormulaVariableStack functionArgumentStack then the FormulaVariable arguments should be named, ARG1, ARG2, etc...
     */
    public static String[][] getRequiredArguments(){
        return requiredArguments;
    }
    
    /**
     *@return String[] description of the return value as well as it's data type
     */
    public static String[] getReturnValueDescription(){
        return returnValueDescription;
    }
    
}