/**

  * Copyright 2009 Timothy Johnston 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.timjohnstondev.unitconverter.logic;

 import java.math.BigDecimal;

 import java.math.MathContext;

 import java.math.RoundingMode;

 /**

  * This parser can take a {@code String} as a formula that contains a variable (must be {@code X}) and the value for

  * that variable, do the calculations to return a {@code BigDecimal}.

  * <p>

  * There can be multiple occurrences of the variable, but only one variable. Symbols it can handle: {@literal (, ), ^,

  * *, /, +, -}

  */

 public final class FormulaParser

 {

   /**

    * The variable letter used in the formulas to be parsed.

    */

   static final String VARIABLE = "X";

   private static StringBuffer formula;

   private static int deleteCharsFromIndex;

   private static int deleteCharsToIndex;

   private static final String OPEN_PAREN = "(";

   private static final String CLOSE_PAREN = ")";

   private static final String POWER_SYMBOL = "^";

   private static final MathContext MATH_CONTEXT = new MathContext(30, RoundingMode.HALF_UP);

   private static final String[] SYMBOLS = {POWER_SYMBOL, "*", "/", "+", "-"};

   private FormulaParser()

   {}

   /**

    * Returns the calculated value of the given formula with the variable value substituted in.

    * 

    * @param variableValue the value of the variable in the formula

    * @param newFormula the formula to be evaluated

    * @return the calculated value

    */

   public static BigDecimal parse(final String variableValue, final String newFormula)

   {

     return parse(new BigDecimal(variableValue), newFormula);

   }

   /**

    * Returns the calculated value of the given formula with the variable value substituted in.

    * 

    * @param variableValue the value of the variable in the formula

    * @param newFormula the formula to be evaluated

    * @return the calculated value

    */

   static BigDecimal parse(final BigDecimal variableValue, final String newFormula)

   {

     final String variable = variableValue.stripTrailingZeros().toPlainString();

     String fullFormula = newFormula.toUpperCase().replaceAll(VARIABLE, variable);

     fullFormula = fullFormula.replaceAll(" ", "");

     formula = new StringBuffer(fullFormula);

     findParens();

     calulate();

     return new BigDecimal(formula.toString());

   }

   private static void findParens()

   {

     findParens(0);

   }

   private static void findParens(final int fromIndex)

   {

     final int openIndex = formula.indexOf(OPEN_PAREN, fromIndex);

     if (openIndex >= fromIndex)

     {

       final int anotherOpenIndex = formula.indexOf(OPEN_PAREN, openIndex + 1);

       int closeIndex = formula.indexOf(CLOSE_PAREN, openIndex);

       cleanupUnclosedParens(closeIndex, openIndex);

       if (anotherOpenIndex > openIndex && anotherOpenIndex < closeIndex)

       {

         goIntoAnotherLayerofParens(anotherOpenIndex);

       }

       closeIndex = formula.indexOf(CLOSE_PAREN, openIndex);

       if (closeIndex > openIndex)

       {

         calulate(openIndex, closeIndex);

         removeParens(openIndex);

       }

       findParens();

     }

   }

   private static void goIntoAnotherLayerofParens(final int index)

   {

     findParens(index);

     final int closeIndex = formula.indexOf(CLOSE_PAREN, index);

     if (closeIndex > index)

     {

       calulate(index, closeIndex);

       removeParens(index);

     }

     findParens();

   }

   private static void cleanupUnclosedParens(final int closeIndex, final int openIndex)

   {

     if (closeIndex == -1)

     {

       formula.deleteCharAt(openIndex);

     }

   }

   private static void removeParens(final int openIndex)

   {

     final int closeIndex = formula.indexOf(CLOSE_PAREN, openIndex);

     formula.deleteCharAt(closeIndex);

     formula.deleteCharAt(openIndex);

   }

   private static void calulate()

   {

     calulate(0, formula.length() - 1);

   }

   private static void calulate(final int fromIndex, final int toIndex)

   {

     int newToIndex = toIndex;

     for (String symbol : SYMBOLS)

     {

       performMath(symbol, fromIndex, newToIndex);

       if (formula.indexOf(CLOSE_PAREN, fromIndex) > 0)

       {

         newToIndex = formula.indexOf(CLOSE_PAREN, fromIndex);

       }

       else

       {

         newToIndex = formula.length() - 1;

       }

     }

   }

   private static void performMath(final String symbol, final int fromIndex, final int toIndex)

   {

     final int index = formula.indexOf(symbol, fromIndex);

     if (index > fromIndex && index < toIndex)

     {

       BigDecimal result = BigDecimal.ZERO;

       final BigDecimal preNumber = getPreNumber(index, fromIndex);

       final BigDecimal postNumber = getPostNumber(index, toIndex, symbol);

       switch (symbol.charAt(0))

       {

         case '^':

           result = preNumber.pow(postNumber.intValue(), MATH_CONTEXT);

           break;

         case '*':

           result = preNumber.multiply(postNumber, MATH_CONTEXT);

           break;

         case '/':

           result = preNumber.divide(postNumber, MATH_CONTEXT);

           break;

         case '+':

           result = preNumber.add(postNumber, MATH_CONTEXT);

           break;

         case '-':

           result = preNumber.subtract(postNumber, MATH_CONTEXT);

           break;

         default:

           break;

       }

       updateFormula(result);

     }

   }

   private static BigDecimal getPreNumber(final int index, final int fromIndex)

   {

     int preIndex = index - 1;

     String preNumber = String.valueOf(formula.charAt(preIndex));

     preIndex--;

     while (preIndex >= fromIndex && isDigit(formula.charAt(preIndex)))

     {

       preNumber = formula.charAt(preIndex) + preNumber;

       preIndex--;

     }

     deleteCharsFromIndex = ++preIndex;

     return new BigDecimal(preNumber);

   }

   private static BigDecimal getPostNumber(final int index, final int toIndex, final String symbol)

   {

     int postIndex = index + 1;

     String postNumber = String.valueOf(formula.charAt(postIndex));

     postIndex++;

     while (postIndex <= toIndex && isDigit(formula.charAt(postIndex), symbol))

     {

       postNumber += formula.charAt(postIndex);

       postIndex++;

     }

     deleteCharsToIndex = postIndex;

     return new BigDecimal(postNumber);

   }

   private static void updateFormula(final BigDecimal result)

   {

     formula.delete(deleteCharsFromIndex, deleteCharsToIndex);

     formula.insert(deleteCharsFromIndex, result.stripTrailingZeros().toPlainString());

     deleteCharsFromIndex = 0;

     deleteCharsToIndex = 0;

   }

   private static boolean isDigit(final char nextChar)

   {

     return isDigit(nextChar, "");

   }

   private static boolean isDigit(final char nextChar, final String symbol)

   {

     boolean isDigit = false;

     if (Character.isDigit(nextChar))

     {

       isDigit = true;

     }

     if (!POWER_SYMBOL.equals(symbol) && ('.' == nextChar || ',' == nextChar))

     {

       isDigit = true;

     }

     return isDigit;

   }

 }