/*
    *  Copyright 2009-2013 Stephen Colebourne
    *
    *  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 org.joda.money.format;
  
  import java.math.BigDecimal;
  import java.text.ParsePosition;
  import java.util.Locale;
  
  import org.joda.money.BigMoney;
  import org.joda.money.CurrencyUnit;
  
  /**
   * Context used when parsing money.
   * <p>
   * This class is mutable and intended for use by a single thread.
   * A new instance is created for each parse.
   */
  public final class MoneyParseContext {
  
      /**
       * The locale to parse using.
       */
      private Locale locale;
      /**
       * The text to parse.
       */
      private CharSequence text;
      /**
       * The text index.
       */
      private int textIndex;
      /**
       * The text error index.
       */
      private int textErrorIndex = -1;
      /**
       * The parsed currency.
       */
      private CurrencyUnit currency;
      /**
       * The parsed amount.
       */
      private BigDecimal amount;
  
      /**
       * Constructor.
       * 
       * @param locale  the locale, not null
       * @param text  the text to parse, not null
       * @param index  the current text index
       */
      MoneyParseContext(Locale locale, CharSequence text, int index) {
          this.locale = locale;
          this.text = text;
          this.textIndex = index;
      }
  
      //-----------------------------------------------------------------------
      /**
       * Gets the locale.
       * 
       * @return the locale, not null
       */
      public Locale getLocale() {
          return locale;
      }
  
      /**
       * Sets the locale.
       * 
       * @param locale  the locale, not null
       */
      public void setLocale(Locale locale) {
          MoneyFormatter.checkNotNull(locale, "Locale must not be null");
          this.locale = locale;
      }
  
      /**
       * Gets the text being parsed.
       * 
       * @return the text being parsed, never null
       */
      public CharSequence getText() {
          return text;
      }
  
     /**
      * Sets the text.
      * 
      * @param text  the text being parsed, not null
      */
     public void setText(CharSequence text) {
         MoneyFormatter.checkNotNull(text, "Text must not be null");
         this.text = text;
     }
 
     /**
      * Gets the length of the text being parsed.
      * 
      * @return the length of the text being parsed
      */
     public int getTextLength() {
         return text.length();
     }
 
     /**
      * Gets a substring of the text being parsed.
      * 
      * @param start  the start index
      * @param end  the end index
      * @return the substring, not null
      */
     public String getTextSubstring(int start, int end) {
         return text.subSequence(start, end).toString();
     }
 
     //-----------------------------------------------------------------------
     /**
      * Gets the current parse position index.
      * 
      * @return the current parse position index
      */
     public int getIndex() {
         return textIndex;
     }
 
     /**
      * Sets the current parse position index.
      * 
      * @param index  the current parse position index
      */
     public void setIndex(int index) {
         this.textIndex = index;
     }
 
     //-----------------------------------------------------------------------
     /**
      * Gets the error index.
      * 
      * @return the error index, negative if no error
      */
     public int getErrorIndex() {
         return textErrorIndex;
     }
 
     /**
      * Sets the error index.
      * 
      * @param index  the error index
      */
     public void setErrorIndex(int index) {
         this.textErrorIndex = index;
     }
 
     /**
      * Sets the error index from the current index.
      */
     public void setError() {
         this.textErrorIndex = textIndex;
     }
 
     //-----------------------------------------------------------------------
     /**
      * Gets the parsed currency.
      * 
      * @return the parsed currency, null if not parsed yet
      */
     public CurrencyUnit getCurrency() {
         return currency;
     }
 
     /**
      * Sets the parsed currency.
      * 
      * @param currency  the parsed currency, may be null
      */
     public void setCurrency(CurrencyUnit currency) {
         this.currency = currency;
     }
 
     //-----------------------------------------------------------------------
     /**
      * Gets the parsed amount.
      * 
      * @return the parsed amount, null if not parsed yet
      */
     public BigDecimal getAmount() {
         return amount;
     }
 
     /**
      * Sets the parsed currency.
      * 
      * @param amount  the parsed amount, may be null
      */
     public void setAmount(BigDecimal amount) {
         this.amount = amount;
     }
 
     //-----------------------------------------------------------------------
     /**
      * Checks if the parse has found an error.
      * 
      * @return whether a parse error has occurred
      */
     public boolean isError() {
         return textErrorIndex >= 0;
     }
 
     /**
      * Checks if the text has been fully parsed such that there is no more text to parse.
      * 
      * @return true if fully parsed
      */
     public boolean isFullyParsed() {
         return textIndex == getTextLength();
     }
 
     /**
      * Checks if the context contains a currency and amount suitable for creating
      * a monetary value.
      * 
      * @return true if able to create a monetary value
      */
     public boolean isComplete() {
         return currency != null && amount != null;
     }
 
     //-----------------------------------------------------------------------
     /**
      * Converts the indexes to a parse position.
      * 
      * @return the parse position, never null
      */
     public ParsePosition toParsePosition() {
         ParsePosition pp = new ParsePosition(textIndex);
         pp.setErrorIndex(textErrorIndex);
         return pp;
     }
 
     /**
      * Converts the context to a {@code BigMoney}.
      * 
      * @return the monetary value, never null
      * @throws MoneyFormatException if either the currency or amount is missing
      */
     public BigMoney toBigMoney() {
         if (currency == null) {
             throw new MoneyFormatException("Cannot convert to BigMoney as no currency found");
         }
         if (amount == null) {
             throw new MoneyFormatException("Cannot convert to BigMoney as no amount found");
         }
         return BigMoney.of(currency, amount);
     }
 
 }