/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans-Common is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components.wheelswitch;
  
  import java.beans.Beans;
  
  import com.cosylab.util.PrintfFormat;
  
  
  /**
   * Formats <code>java.lang.String</code>s to be displayed as digits in  the
   * <code>Wheelswitch</code>. The format is specified in a format
   * <code>java.lang.String</code>. <code>WheelswitchFormatter</code> also
   * stores the value, its bounds (minimum and maximum) and also the unit
   * displayed by the <code>Wheelswitch</code>.
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   */
  public abstract class AbstractWheelswitchFormatter
  {
  	protected PrintfFormat defFormatter;
  	protected PrintfFormat formatter;
  	protected String formatString = null;
  	protected String generatedFormatString = null;
  	protected String unit = null;
  	protected String valueString = "0.00";
  	protected double maximum;
  	protected double minimum;
  	protected double value = 0.;
  	protected int maximumDigits = 42;
  	protected boolean debug = false;
  
  	/**
  	 * Constructs the PlainWheelswitchFormatter and sets the format  string.
  	 *
  	 * @param newFormatString
  	 *
  	 * @see #setFormat(String)
  	 */
  	public AbstractWheelswitchFormatter(String newFormatString)
  	{
  		super();
  		defFormatter = new PrintfFormat("%3.2e");
  		setMaximum(Double.POSITIVE_INFINITY);
  		setMinimum(Double.NEGATIVE_INFINITY);
  		setFormat(newFormatString);
  	}
  
  	/**
  	 * Constructs the PlainWheelswitchFormatter with no format string.
  	 *
  	 * @see #setFormat(String)
  	 */
  	public AbstractWheelswitchFormatter()
  	{
  		this(null);
  	}
  
  	/**
  	 * Sets the format string specifiing the format of <code>Wheelswitch</code>
  	 * display. The format is first checked for validity by the
  	 * <code>checkFormat(String)</code> method.
  	 *
  	 * @param newFormatString
  	 *
  	 * @throws IllegalArgumentException DOCUMENT ME!
  	 *
  	 * @see Double#parseDouble(String)
  	 * @see NumberFormatException
  	 */
  	public void setFormat(String newFormatString)
  		throws IllegalArgumentException
  	{
  		if (debug) System.out.println("WheelswitchFormatter::setFormat = "+newFormatString);
  		
  		if (newFormatString == formatString || Beans.isDesignTime()) {
  			return;
  		} else if (newFormatString == null || newFormatString == "") {
  			formatString = null;
  			generatedFormatString = null;
  			formatter = new PrintfFormat(transformFormat(generateFormat()));
 		} else if (checkFormat(newFormatString)) {
 			formatString = newFormatString;
 			formatter = new PrintfFormat(transformFormat(newFormatString));
 		} else {
 			throw (new IllegalArgumentException(
 			    "Invalid format string entered."));
 		}
 
 		setString(String.valueOf(value));
 	}
 
 	/**
 	 * Returns the currently stored format string.
 	 *
 	 * @return the format
 	 */
 	public String getFormat()
 	{
 		return formatString;
 	}
 
 	/**
 	 * Sets a new maximum allowed value.
 	 *
 	 * @param newMaximum new maximum value
 	 */
 	public void setMaximum(double newMaximum)
 	{
 		if (newMaximum < minimum) {
 			newMaximum = minimum;
 		}
 
 		maximum = newMaximum;
 
 		if (formatString == null) {
 			generatedFormatString = null;
 			formatter = new PrintfFormat(transformFormat(generateFormat()));
 		}
 	}
 
 	/**
 	 * Returns the current maximum allowed value.
 	 *
 	 * @return double
 	 */
 	public double getMaximum()
 	{
 		return maximum;
 	}
 
 	/**
 	 * Sets a new minimum allowed value.
 	 *
 	 * @param newMinimum new minimum value
 	 */
 	public void setMinimum(double newMinimum)
 	{
 		if (newMinimum > maximum) {
 			newMinimum = maximum;
 		}
 
 		minimum = newMinimum;
 
 		if (formatString == null) {
 			generatedFormatString = null;
 			formatter = new PrintfFormat(transformFormat(generateFormat()));
 		}
 	}
 
 	/**
 	 * Returns the current minimum allowed value.
 	 *
 	 * @return the minimum
 	 */
 	public double getMinimum()
 	{
 		return minimum;
 	}
 
 	/**
 	 * Sets the value as string.
 	 *
 	 * @param newValueString String representing the number to be formatted.  
 	 * 		It only accepts values within bounds (maximum and minimum).
 	 */
 	public void setString(String newValueString)
 	{
 		//Debug.out("WheelswitchFormatter#setString(): newValueString=" + newValueString);
 		//Debug.out("WheelswitchFormatter#setString(): formatString=" + formatString);
 
 		double newValue = Double.parseDouble(newValueString);
 
 		if (newValue > maximum || newValue < minimum) {
 			setValue(trimValue(newValue));
 		} else {
 			internalSetString(newValueString);
 		}
 	}
 	
 	/**
 	 * Returns the formatted string representing the currently stored value.
 	 *
 	 * @return value as string
 	 */
 	public String getString()
 	{
 		String retVal = valueString;
 
 		if (maximumDigits > 0 && maximumDigits < valueString.length()) {
 			retVal = defFormatter.sprintf(value);
 		}
 
 		return retVal;
 	}
 
 	/**
 	 * Sets a new value and stores its formatted string. It accepts any value.
 	 *
 	 * @param newValue new value
 	 *
 	 */
 	public void setValue(double newValue)
 	{
 		if (debug) System.out.println("WheelswitchFormatter:SET VALUE: " + newValue);
 		
 		internalSetString(String.valueOf(newValue));
 	}
 	
 	/*
 	 * Sets value and valueString when newValueString is set.
 	 */
 	protected abstract void internalSetString(String newValueString);
 
 	private double trimValue(double newValue) {
 		if (newValue > maximum) {
 			return maximum;
 		} else if (newValue < minimum) {
 			return minimum;
 		}
 		
 		return newValue;
 	}
 	
 	/**
 	 * Returns the currently stored value.
 	 *
 	 * @return the value
 	 */
 	public double getValue()
 	{
 		return value;
 	}
 
 	/**
 	 * Checks the number format string. The format string should only  consist
 	 * of characters '#' reperesenting a single number digit, '+' representing
 	 * a sign digit, '.' representing the decimal symbol  digit and 'E'
 	 * representing the exponent denominator. These  characters should be
 	 * arranged in such way that substitution of  the characters '#' with any
 	 * numerical digits would result in a  correct double expression
 	 * acceptible by <code>Double.parseDouble()</code>.
 	 *
 	 * @param format
 	 *
 	 * @return true if a correct format string was entered, false otherwise.
 	 */
 	public static boolean checkFormat(String format)
 	{
 		boolean dotted = false;
 		boolean edotted = false;
 
 		for (int i = 0; i < format.length(); i++) {
 			if (format.charAt(i) != '#' && format.charAt(i) != '.'
 			    && format.charAt(i) != 'E' && format.charAt(i) != '+') {
 				return false;
 			}
 
 			if (format.charAt(i) == '.') {
 				if (dotted) {
 					return false;
 				} else {
 					dotted = true;
 				}
 			}
 
 			if (format.charAt(i) == 'E') {
 				if (edotted) {
 					return false;
 				} else {
 					dotted = edotted = true;
 				}
 
 				if (i == format.length() - 1) {
 					return false;
 				}
 			}
 
 			if (format.charAt(i) == '+') {
 				if (i != 0 && format.charAt(i - 1) != 'E') {
 					return false;
 				}
 
 				if (i == format.length() - 1) {
 					return false;
 				}
 
 				if (format.charAt(i + 1) == 'E') {
 					return false;
 				}
 			}
 		}
 
 		return true;
 	}
 
 	/**
 	 * A conviniance method for transforming between the  Printf type format
 	 * strings and wheelswitch type format strings. The transform can be used
 	 * in either direction. The method does not check for validity of the
 	 * supplied parameter string and may return bogus results if invalid
 	 * format strings are passed to it.
 	 *
 	 * @param format 
 	 *
 	 * @return transformed format
 	 *
 	 * @throws NullPointerException if format is null
 	 * @throws IllegalArgumentException if format is not supported (does not include
 	 * 		f,d,i,e or E tag)
 	 */
 	public static String transformFormat(String format)
 	{
 		String retVal = new String();
 
 		if (format == null) {
 			throw new NullPointerException("format");
 		}
 
 		if (checkFormat(format)) {
 			int expIndex = format.indexOf('E');
 
 			if (expIndex == -1) {
 				expIndex = format.indexOf('e');
 			}
 
 			if (expIndex == -1) {
 				expIndex = format.length();
 			}
 
 			int dotIndex = format.indexOf('.');
 
 			if (dotIndex == -1) {
 				dotIndex = expIndex;
 			}
 
 			if (expIndex > dotIndex) {
 				expIndex--;
 			}
 
 			int signTag = ((format.charAt(0) == '+') ? (1) : (0));
 			retVal = "%";
 
 			if (signTag == 1) {
 				retVal += "+";
 			}
 
 			retVal += String.valueOf(expIndex - signTag) + "."
 			+ String.valueOf(expIndex - dotIndex) + "f";
 		} else {
 			int startIndex = format.indexOf('%');
 			boolean signTag = format.charAt(startIndex + 1) == '+';
 			boolean exp = false;
 
 			if (signTag) {
 				startIndex++;
 			}
 
 			int finishIndex = format.indexOf('f', startIndex);
 
 			if (finishIndex < 0) {
 				finishIndex = format.indexOf('d', startIndex);
 			}
 
 			if (finishIndex < 0) {
 				finishIndex = format.indexOf('i', startIndex);
 			}
 
 			if (finishIndex < 0) {
 				finishIndex = format.indexOf('e', startIndex);
 				exp = true;
 			}
 
 			if (finishIndex < 0) {
 				finishIndex = format.indexOf('E', startIndex);
 				exp = true;
 			}
 
 			if (finishIndex < 0) {
 				throw new IllegalArgumentException(
 				    "Unsuported or invalid format string '" + format + "'!");
 			}
 
 			int dotIndex = format.indexOf('.', startIndex);
 
 			if (dotIndex == -1 || dotIndex > finishIndex) {
 				dotIndex = finishIndex;
 			}
 
 			int lengthDecimal = dotIndex + 1 >= finishIndex ? 0
 				: Integer.parseInt(format.substring(dotIndex + 1, finishIndex));
 			int lengthAll = startIndex + 1 == dotIndex ? lengthDecimal + 1
 				: Integer.parseInt(format.substring(startIndex + 1, dotIndex));
 			int lengthInteger = Math.max(1, lengthAll - lengthDecimal);
 
 			if (signTag) {
 				retVal += "+";
 			}
 
 			for (int i = 0; i < lengthInteger; i++) {
 				retVal += "#";
 			}
 
 			if (dotIndex < finishIndex) {
 				retVal += ".";
 
 				for (int i = 0; i < lengthDecimal; i++) {
 					retVal += "#";
 				}
 			}
 
 			if (exp) {
 				retVal += "E";
 
 				if (finishIndex + 1 == format.length()) {
 					retVal += "#";
 				} else {
 					if (format.charAt(finishIndex + 1) == '+') {
 						retVal += "+";
 						finishIndex++;
 					}
 
 					finishIndex++;
 
 					int num = 0;
 
 					while (finishIndex + num < format.length()
 					    && Character.isDigit(format.charAt(finishIndex + num))) {
 						num++;
 					}
 
 					int val = Integer.parseInt(format.substring(finishIndex,
 						        finishIndex + num));
 
 					for (int i = 0; i < val; i++) {
 						retVal += "#";
 					}
 				}
 			}
 		}
 
 		return retVal;
 	}
 
 	/**
 	 * Sets the maximum allowed number of digits to represent the value.
 	 *
 	 * @param i new maximum number of digits
 	 */
 	public void setMaximumDigits(int i)
 	{
 		maximumDigits = i;
 	}
 
 	/**
 	 * Returns the maximum allowed number of digits to represent the value.
 	 *
 	 * @return number of allowed digits.
 	 */
 	public int getMaximumDigits()
 	{
 		return maximumDigits;
 	}
 
 	/**
 	 * Sets the unit.
 	 *
 	 * @param unit new units
 	 */
 	public void setUnit(String unit)
 	{
 		this.unit = unit;
 	}
 
 	/**
 	 * Returns the unit.
 	 *
 	 * @return String
 	 */
 	public String getUnit()
 	{
 		return unit;
 	}
 
 	/*
 	 * A format string generator used when no format string is set
 	 * to the wheelswitch. The format string is determined from value bounds
 	 * so that all possible values in range can be displayed with the same number
 	 * and position of digits.
 	 */
 	protected String generateFormat()
 	{
 		if (generatedFormatString == null) {
 			if (maximum == Double.POSITIVE_INFINITY
 			    || minimum == Double.NEGATIVE_INFINITY) {
 				generatedFormatString = "+#.##E+###";
 			} else {
 				double abs = Math.max(Math.abs(minimum), Math.abs(maximum));
 				int integer = 0;
 
 				while (Math.floor(abs) > 0) {
 					abs /= 10;
 					integer++;
 				}
 
 				integer = Math.max(integer, 1);
 
 				abs = Math.min(Math.abs(minimum), Math.abs(maximum));
 
 				int decimal = 0;
 
 				while (Math.floor(abs) == 0 && abs != 0) {
 					decimal++;
 					abs *= 10;
 				}
 
 				generatedFormatString = new String();
 
 				//fix for default format string with '+'
 				if (true || minimum < 0) {
 					generatedFormatString += "+";
 				}
 
 				for (int i = 0; i < integer; i++) {
 					generatedFormatString += "#";
 				}
 
 				if (decimal > 0) {
 					generatedFormatString += ".";
 				}
 
 				for (int i = 0; i < decimal; i++) {
 					generatedFormatString += "#";
 				}
 			}
 		}
 
 		return generatedFormatString;
 	}
 }
 
 /* __oOo__ */