/*
    * 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.range2;
  
  
  /**
   * Uses Range to find optimal tick distribution for LinearRange.
   *
   * @author <a href="mailto:nejc.kosnik@kgb.ijs.si">Nejc Kosnik</a>
   * @version $id$
   */
  public class LinearTickCalculator implements TickCalculator
  {
  
  	private static class TickStep
  	{
  		/** Factors for stretching and shrinking tickstep */
  		public static final double[] FACTORS = { 2, 2.5, 2 };
  		/** Current tickstep */
  		private double tep;
  		/** If the last performed stepchange has been stretching. */
  		private boolean multipliedBefore;
  		private int i;
  		
  		/**
  		 * Shrinks tickstep.
  		 */
  		public void divStep()
  		{
  			if (multipliedBefore) {
  				i = change(-1);
  				multipliedBefore = false;
  			}
  
  			tep /= FACTORS[i];
  			i = change(-1);
  		}
  
  		/**
  		 * Stretches tickstep.
  		 */
  		public void mulStep()
  		{
  			if (!multipliedBefore) {
  				i = change(1);
  				multipliedBefore = true;
  			}
  
  			tep *= FACTORS[i];
  			i = change(+1);
  		}
  
  		/**
  		 * Creates a new TickStep object.
  		 *
  		 * @param step Initial step
  		 * @param start Which index in <code>FACTORS</code> should be used for
  		 *        stretching first.
  		 * @param multipliedBefore Should be current
  		 *        <code>FACTORS[start]</code> used for first stretching.
  		 */
  		public TickStep(double step, int start, boolean multipliedBefore)
  		{
  			i = start;
  			this.tep = step;
  			this.multipliedBefore = multipliedBefore;
  		}
  
  		private int change(int di)
  		{
  			if (i == FACTORS.length - 1 && di == 1) {
  				return 0;
  			}
  
  			if (i == 0 && di == -1) {
  				return 2;
  			}
  
  			return i + di;
  		}
  	}
  
 	private int tickSpacing;
 	private boolean boundTicksVisible;
 
 	/**
 	 * Creates a new LinearTickCollector object.
 	 *
 	 * @param tickSpacing Minimum space between minor ticks.
 	 * @param boundTicksVisible a flag indicating whether the range's bounds should be visible
 	 */
 	public LinearTickCalculator(int tickSpacing, boolean boundTicksVisible)
 	{
 		this.tickSpacing = tickSpacing;
 		this.boundTicksVisible = boundTicksVisible;
 	}
 	
 	/**
 	 * @param length Available space in pixels.
 	 * @param measurer
 	 * @param range
 	 * @param rangedVal
 	 * @return
 	 */
 	private Tick[] internalCalculateTicks(int length, TickParameters measurer, Range range, RangedValue rangedVal)
 	{	
 		if (measurer == null) measurer = new DefaultTickParameters(50, "%0.6g");
 		double min = rangedVal.getMinimum();
 		double max = rangedVal.getMaximum();
 		TickStep s = new TickStep(getRStep(min, max), 0, true);
 		boolean zeroOnScale = isInRange(0, min, max);
 		
 		double rmin = getRmin(min, s, zeroOnScale);
 		double rmax = getRmax(rmin, max, s);
 
 		int nticks = (int)((rmax - rmin) / s.tep) + 1;
 
 		double tickSpace = (range.toRelative(rmax,rangedVal)
 			- range.toRelative(rmax - s.tep,rangedVal)) * length;
 
 		// try to increase major tick density
 		while (tickSpace != 0 && nticks < 6 /* || tickSpace > 20*tickSpacing*/) {
 			s.divStep();
 			rmin = getRmin(min, s, zeroOnScale);
 			rmax = getRmax(rmin,max, s);
 			nticks = (int)((rmax - rmin) / s.tep) + 1;
 			tickSpace = (range.toRelative(rmax,rangedVal)
 				- range.toRelative(rmax - s.tep,rangedVal)) * length;
 
 			//	tickSpace = ((rmax - rmin) / (max - min) * length - nticks) / (nticks
 			//		- 1);
 		}
 		
 		//we might have to decrease major ticks count
 		while (tickSpace < tickSpacing || nticks > 25) {
 			s.mulStep();
 			rmin = getRmin(rmin, s, zeroOnScale);
 			rmax = getRmax(rmin, max, s);
 
 			if (rmin == rmax || Double.isNaN(rmin) || Double.isNaN(rmax)
 			    || Double.isInfinite(rmin) || Double.isInfinite(rmax)) {
 				if (boundTicksVisible) {
 					return new Tick[]{
 						new Tick(min, 0, true, ""), new Tick(max, 1, true, "")
 					};
 				} else if (zeroOnScale) {
 					return new Tick[]{
 						new Tick(0,range.toRelative(0,rangedVal), true,
 								measurer.formatNumber(0))
 					};
 				} else {
 					return new Tick[]{
 						new Tick(rmin,range.toRelative(rmin,rangedVal), true,
 								measurer.formatNumber(rmin))
 					};
 				}
 			}
 
 			nticks = (int)((rmax - rmin) / s.tep) + 1;
 			tickSpace = (range.toRelative(rmax,rangedVal)
 				- range.toRelative(rmax - s.tep,rangedVal)) * length;
 		}
 
 		//from now on we have to deal with labels
 		double rstep = s.tep;
 		TickStep ls = new TickStep(s.tep, s.i, s.multipliedBefore);
 		double rminL = rmin;
 		double rmaxL = rmax;
 
 		//measuring tick labels
 		double x;
 
 		while (true) {
 			// rstepL/10 is instead of zero to prevent round-off errors 
 			for (x = rminL; x < rmaxL - ls.tep / 10; x += ls.tep) {
 				if (measurer.measureTick(range.toRelative(x,rangedVal),
 						measurer.formatNumber(x))
 				    + measurer.measureTick(range.toRelative(x + ls.tep,rangedVal),
 				    		measurer.formatNumber(x + ls.tep)) > 1.3 * (range
 				    .toRelative(x + ls.tep,rangedVal) - range.toRelative(x,rangedVal)) * length) {
 					break;
 				}
 			}
 
 			if (x >= rmaxL - ls.tep / 10) {
 				break;
 			} else {
 				ls.mulStep();
 				rminL = getRmin(min, ls, zeroOnScale);
 				rmaxL = getRmax(rminL, max, ls);
 			}
 		}
 
 		if ((int)((rmaxL - rminL) / ls.tep) + 1 > 12) { //to many labeled ticks
 			ls.mulStep();
 			rminL = getRmin(min, ls, zeroOnScale);
 			rmaxL = getRmax(rminL, max, ls);
 		}
 
 		rstep = ls.tep / 2;
 		rmin = getRmin(min, new TickStep(rstep, 0, true), zeroOnScale);
 		rmax = getRmax(rmin, max, new TickStep(rstep, 0, true));
 
 		//minor ticks
 		double minorStep = rstep / 5;
 		double minorMin = getRmin(min, new TickStep(minorStep, 0, true), zeroOnScale);
 		double minorMax = getRmax(minorMin, max, new TickStep(minorStep, 0, true));
 
 		if ((range.toRelative(minorMax,rangedVal)
 		    - range.toRelative(minorMax - minorStep,rangedVal)) * length > tickSpacing) {
 			//everything done already
 		} else {
 			minorStep = rstep / 2;
 			minorMin = getRmin(min, new TickStep(minorStep, 0, true), zeroOnScale);
 			minorMax = getRmax(minorMin, max, new TickStep(minorStep, 0, true));
 
 			if ((range.toRelative(minorMax,rangedVal)
 			    - range.toRelative(minorMax - minorStep,rangedVal)) * length > tickSpacing) {
 				//everything done already
 			} else {
 				minorStep = rstep;
 			}
 		}
 
 		minorMin = getRmin(min, new TickStep(minorStep, 0, true), zeroOnScale);
 		minorMax = getRmax(minorMin, max, new TickStep(minorStep, 0, true));
 
 		nticks = Math.round(Math.round((rmax - rmin) / rstep) *	Math.round(rstep / minorStep)
 			    + Math.round((minorMax - rmax + rmin - minorMin) / minorStep)) + 1;
 
 		if (nticks == 0) {
 			Tick[] ticks = new Tick[1];
 			ticks[0] = new Tick(0,range.toRelative(0,rangedVal), true, measurer.formatNumber(0));
 
 			return ticks;
 		}
 
 		int i = 0;
 		int di = 0;
 
 		if (boundTicksVisible) {
 			if ((rmin - min) / (max - min) > 0.01
 			    || (max - rmin) / (max - min) > 0.01) {
 				nticks += 2;
 				i = 1;
 				di = 1;
 			}
 		}
 
 		Tick[] ticks = new Tick[nticks];
 
 		if (i == 1) {
 			//			this tick was unlabelled originally
 			ticks[0] = new Tick(rmin, 0.0, true, "");
 		}
 
 		int ratio2 = (int)Math.round(ls.tep / minorStep);
 		int ratio1 = (int)Math.round(rstep / minorStep);
 		x = minorMin;
 
 		for (; x < rmin - minorStep / 10; i++, x += minorStep) {
 			ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
 		}
 
 		int cont = 0;
 		
 		for (int k = 0; x < rminL - minorStep / 10; i++, k++, x += minorStep) {
 			if (k % ratio1 == 0) {
 				x = rmin + (cont++) * rstep; //to prevent round off errors
 				ticks[i] = new Tick(x, range.toRelative(x,rangedVal), true, "");
 			} else {
 				ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
 			}
 		}
 
 		for (int k = 0; i < nticks - di; i++, k++, x += minorStep) {
 			if (k % ratio2 == 0) {
 				x = rmin + (cont++) * rstep; //to prevent round off errors
 				x = (Math.abs(x) != 0.0 ? x : Math.abs(x)); //to prevent ugly negative zero representation -0.0 
 				ticks[i] = new Tick(x, range.toRelative(x,rangedVal), true,
 					    /*formatter.sprintf(x)*/ measurer.formatNumber(x));
 			} else if (k % ratio1 == 0) {
 				x = rmin + (cont++) * rstep; //to prevent round off errors
 				ticks[i] = new Tick(x, range.toRelative(x,rangedVal), true, "");
 			} else {
 				ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
 			}
 		}
 
 		if (di == 1) {
 			//this tick was unlabelled originally
 			ticks[i] = new Tick(rmax, 1.0, true, "");
 		}
 		
 		return ticks;
 	}
 	
 	private double getRmin(double min, TickStep s, boolean zeroOnScale)
 	{
 		double rmin;
 
 		if (zeroOnScale) {
 			rmin = -Math.floor(-min / s.tep) * s.tep;
 
 			if (rmin == -0.0) {
 				rmin = 0.0;
 			}
 		} else {
 			rmin = (min < 0 ? -Math.floor(-min / s.tep) * s.tep
 				: Math.ceil(min / s.tep) * s.tep);
 		}
 
 		return rmin;
 	}
 
 	private double getRmax(double rmin, double max, TickStep s)
 	{
 		// conversion to float makes rounder values
 		return rmin + Math.floor((float)((max - rmin) / s.tep)) * s.tep;
 	}
 
 	private double getRStep(double min, double max)
 	{
 		double rstep;
 
 		if (Math.abs(max) > Math.abs(min)) {
 			rstep = Math.pow(10,
 				    Math.floor(Math.log(Math.abs(max)) / Math.log(10)));
 		} else {
 			rstep = Math.pow(10,
 				    Math.floor(Math.log(Math.abs(min)) / Math.log(10)));
 		}
 
 		return rstep;
 	}
 
 	private boolean isInRange(double value, double min, double max)
 	{
 		return (value >= min && value <= max);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.range2.TickCalculator#calculateTicks(com.cosylab.gui.components.range2.Range, com.cosylab.gui.components.range2.RangedValue)
 	 */
 	public Tick[] calculateTicks(int length, Range range, RangedValue rangedValue) {
 		return calculateTicks(length, new DefaultTickParameters(50, "%0.6g"), range, rangedValue);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.range2.TickCalculator#calculateTicks(com.cosylab.gui.components.range2.TickParameters, com.cosylab.gui.components.range2.Range, com.cosylab.gui.components.range2.RangedValue)
 	 */
 	public Tick[] calculateTicks(int length, TickParameters measurer, Range range, RangedValue rangedValue) {
 		return internalCalculateTicks(length, measurer, range, rangedValue);
 	}
 }
 
 /* __oOo__ */