/**
    * 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;
   }
 }