/*
    * 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 LogarithmicRange.
   *
   * @author <a href="mailto:nejc.kosnik@kgb.ijs.si">Nejc Kosnik</a>
   * @version $id$
   */
  public class LogarithmicTickCalculator implements TickCalculator
  {
  	/**
  	 * Creates a new TickCollector object.
  	 *
  	 * @param range Definition of range.
  	 * @param tickSpacing Minimum space between minor ticks.
  	 * @param length Available space in pixels.
  	 */
  	public LogarithmicTickCalculator(int tickSpacing, boolean boundTicksVisible)
  	{
  
  		this.tickSpacing = tickSpacing;
  		this.boundTicksVisible = boundTicksVisible;
  	}
  
  	private int tickSpacing;
  	private boolean boundTicksVisible;
  
  	private Tick[] internalCalculateTicks(int length, TickParameters measurer, Range range, RangedValue rangedVal)
  	{	
  		if (measurer == null) measurer = new DefaultTickParameters(50, "%0.4g");
  		double min = rangedVal.getMinimum();
  		double max = rangedVal.getMaximum();
  		double tickFactorLog = 1;
  		double rmaxLog = Math.floor(logg(1.00000001*max));
  		double rminLog = Math.ceil(logg(0.99999999*min));
  		double tickSpace;
  		int nticks;
  		boolean minorTicksDrawn;
  
  		//no major ticks in the range, user is probably missusing logarithmic range
  		if(Math.pow(10, rmaxLog) < min || Math.pow(10, rminLog) > max) {
  			int i;
  			double x;
  			double step = Math.pow(10, rmaxLog);
  			Tick[] ticks;
  
  			for(x = step; x < min; x += step) {
  				;
  			}
  
  			rminLog = Math.round(x / step) * step;
  
  			for(; x <= max; x += step) {
  				;
  			}
  
  			rmaxLog = Math.round(x / step - 1) * step;
  
  			nticks = (int)Math.round((rmaxLog - rminLog) / step + 1);
  
  			if(nticks == 1) {
  				return onlyOneTick(rminLog, boundTicksVisible, min, max, range, rangedVal);
  			}
  
  			tickSpace = (range.toRelative(rmaxLog,rangedVal)
  				- range.toRelative(rmaxLog - step,rangedVal)) * length;
  
  			if(tickSpace > tickSpacing) {
  				ticks = (boundTicksVisible ? new Tick[nticks + 2]
  					: new Tick[nticks]);
  
  				if(boundTicksVisible) {
  //					this tick was unlabelled originally
  					ticks[0] = new Tick(min, range.toRelative(min,rangedVal), true, "");
  
  					for(i = 1, x = rminLog; x <= rmaxLog; x += step, i++) {
  						ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
  					}
  //					this tick was unlabelled originally
  					ticks[nticks + 1] = new Tick(max, range.toRelative(max,rangedVal), true,  "");
 
 					return ticks;
 				} else {
 					for(i = 0, x = rminLog; x <= rmaxLog; x += step, i++) {
 						ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
 					}
 
 					return ticks;
 				}
 			}
 
 			step *= 2.0;
 
 			for(x = step; x < min; x += step) {
 				;
 			}
 
 			rminLog = Math.round(x / step) * step;
 
 			for(; x <= max; x += step) {
 				;
 			}
 
 			rmaxLog = Math.round(x / step - 1) * step;
 			nticks = (int)Math.round((rmaxLog - rminLog) / step + 1);
 
 			if(nticks == 1) {
 				return onlyOneTick(rminLog, boundTicksVisible, min, max, range, rangedVal);
 			}
 
 			tickSpace = (range.toRelative(rmaxLog,rangedVal)
 				- range.toRelative(rmaxLog - step,rangedVal)) * length;
 
 			if(tickSpace > tickSpacing) {
 				ticks = (boundTicksVisible ? new Tick[nticks + 2]
 					: new Tick[nticks]);
 
 				if(boundTicksVisible) {
 //					this tick was unlabelled originally			
 					ticks[0] = new Tick(min, range.toRelative(min,rangedVal), true, "");
 
 					for(i = 1, x = rminLog; x <= rmaxLog; x += step, i++) {
 						ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
 					}
 
 //					this tick was unlabelled originally
 					ticks[nticks + 1] = new Tick(max, range.toRelative(max,rangedVal), true, "");
 
 					return ticks;
 				} else {
 					for(i = 0, x = rminLog; x <= rmaxLog; x += step, i++) {
 						ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
 					}
 
 					return ticks;
 				}
 			}
 
 			step = Math.pow(10, Math.floor(logg(min)));
 
 			if(min <= 5 * step && max >= 5 * step) {
 				rminLog = 5 * step;
 
 				return onlyOneTick(rminLog, boundTicksVisible, min, max, range, rangedVal);
 			} else {
 				ticks = new Tick[0];
 
 				return ticks;
 			}
 		}
 
 		//end of no-major-ticks case
 		nticks = (int)((rmaxLog - rminLog) / tickFactorLog) + 1;
 		tickSpace = (range.toRelative(Math.pow(10, rmaxLog),rangedVal)
 			- range.toRelative(Math.pow(10, rminLog),rangedVal)) * length / nticks;
 
 		//we might have to decrease major ticks count
 		while(tickSpace < tickSpacing || nticks > 25) {
 			tickFactorLog++;
 			rminLog = rmaxLog
 				- Math.floor((rmaxLog - rminLog) / tickFactorLog) * tickFactorLog;
 
 			nticks = (int)((rmaxLog - rminLog) / tickFactorLog) + 1;
 			tickSpace = (range.toRelative(Math.pow(10, rmaxLog),rangedVal)
 				- range.toRelative(Math.pow(10, rminLog),rangedVal)) * length / nticks;
 
 			if(rminLog == rmaxLog) {
 				break;
 			}
 		}
 
 		//only one major tick
 		if(rminLog == rmaxLog) {
 			double r = Math.max(Math.pow(10, rminLog) - min,
 				    0.1 * (max - Math.pow(10, rmaxLog)));
 			double step;
 
 			if(r < 0.1) {
 				if(boundTicksVisible) {
 					return new Tick[] {
 						new Tick(min, 0, true, ""), new Tick(max, 1, true, "")
 					};
 				} else {
 					return new Tick[] {
 						new Tick(rminLog, range.toRelative(Math.pow(10, rminLog),rangedVal), true,
 								measurer.formatNumber(Math.pow(10, rminLog)))
 					};
 				}
 			}
 
 			minorTicksDrawn = (range.toRelative(Math.pow(10, rminLog),rangedVal)
 				- range.toRelative(0.9 * Math.pow(10, rminLog),rangedVal)) * length > tickSpacing;
 
 			double majorTick = Math.pow(10, rminLog);
 			step = 0.1 * majorTick;
 
 			double x;
 
 			for(x = Math.pow(10, rminLog); x >= min; x -= step) {
 				;
 			}
 
 			rminLog = x + step;
 
 			for(x = Math.pow(10, rminLog); x <= max; x += step) {
 				;
 			}
 
 			rmaxLog = x - step;
 			nticks = (int)Math.round((rmaxLog - rminLog) / step + 1);
 
 			Tick[] ticks = new Tick[nticks];
 			int i;
 
 			for(i = 0, x = rminLog; x < majorTick; x += step, i++) {
 				ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
 			}
 
 			ticks[i++] = new Tick(x, range.toRelative(x,rangedVal), true,
 					measurer.formatNumber(x));
 			step *= 10;
 			x += step;
 
 			for(; x <= max; x += step, i++) {
 				ticks[i] = new Tick(x, range.toRelative(x,rangedVal), false);
 			}
 
 			if(boundTicksVisible) {
 				Tick[] ticks2 = new Tick[nticks + 2];
 				//unlabelled originally
 				ticks2[0] = new Tick(min, 0, true, "");
 
 				for(i = 1; i <= nticks; i++) {
 					ticks2[i] = ticks[i - 1];
 				}
 
 				ticks2[i] = new Tick(max, 1.0, true, "");
 
 				return ticks2;
 			}
 
 			return ticks;
 		}
 		double rminLLog = rminLog;
 		double rmaxLLog = rmaxLog;
 		double tickFactorLLog = tickFactorLog;
 
 		//measuring tick labels
 		double x;
 
 		while(true) {
 			for(x = rminLLog; x < rmaxLLog - 0.1; x += tickFactorLLog) {
 				if(measurer.measureTick(range.toRelative(Math.pow(10, x),rangedVal),
 						measurer.formatNumber(Math.pow(10, x)))
 				    + measurer.measureTick(range.toRelative(Math.pow(10,
 				                x + tickFactorLLog),rangedVal),
 				                measurer.formatNumber(Math.pow(10, x + tickFactorLLog))) > 1.5 * (range
 				    .toRelative(Math.pow(10, x + tickFactorLLog),rangedVal)
 				    - range.toRelative(Math.pow(10, x),rangedVal)) * length) {
 					break;
 				}
 			}
 
 			if(x >= rmaxLLog) {
 				break;
 			} else {
 				tickFactorLLog = (tickFactorLog == 1 ? tickFactorLLog + 1
 					: 2 * tickFactorLLog);
 				rminLLog = rmaxLLog
 					- Math.floor((rmaxLLog - rminLog) / tickFactorLLog) * tickFactorLLog;
 			}
 		}
 
 		if((rmaxLLog - rminLLog) / tickFactorLLog + 1 > 12) { //to many labeled ticks
 			tickFactorLLog++;
 			rminLLog = rmaxLLog
 				- Math.floor((rmaxLLog - rminLLog) / tickFactorLLog) * tickFactorLLog;
 		}
 
 		int factor = 1;
 		minorTicksDrawn = (range.toRelative(Math.pow(10, rmaxLog),rangedVal)
 			- range.toRelative(0.9 * Math.pow(10, rmaxLog),rangedVal)) * length > tickSpacing
 			&& Math.round(tickFactorLog) == 1;
 
 		if(minorTicksDrawn) {
 			; // nothing to do here
 		} else if((range.toRelative(Math.pow(10, rmaxLog),rangedVal)
 		    - range.toRelative(0.8 * Math.pow(10, rmaxLog),rangedVal)) * length > tickSpacing
 		    && Math.round(tickFactorLog) == 1) {
 			minorTicksDrawn = true;
 			factor = 2;
 		} else if((range.toRelative(Math.pow(10, rmaxLog),rangedVal)
 		    - range.toRelative(0.5 * Math.pow(10, rmaxLog),rangedVal)) * length > tickSpacing
 		    && Math.round(tickFactorLog) == 1) {
 			minorTicksDrawn = true;
 			factor = 5;
 		}
 
 		double step;
 		double rmin;
 		double rmax;
 
 		if(minorTicksDrawn) {
 			rmax = Math.pow(10, rmaxLog + 1);
 			step = rmax * factor / 10;
 
 			while(rmax > 1.00000001*max) {
 				rmax -= step;
 			}
 
 			rmin = Math.pow(10, rminLog - 1) * factor;
 			step = rmin;
 
 			while(rmin < 0.99999999*min) {
 				rmin += step;
 			}
 			nticks = (int)Math.round((factor == 1 ? 9 : 10 / factor) * (rmaxLog
 			- rminLog) + 1
 			+ rmax / (factor * Math.pow(10,
 				rmaxLog))- (factor == 1 ? 1 : 0)
 			+ (Math.pow(10, rminLog) - rmin) / (factor * Math.pow(10,
 				rminLog - 1)));
 				 
 		} else {
 			nticks = (int)((rmaxLog - rminLog) / tickFactorLog + 1);
 			rmin = Math.pow(10, rminLog);
 			step = rmin;
 		}
 		Tick[] ticks = new Tick[nticks];
 
 		int kmax = (int)Math.round(10.0 / factor);
 		int kmin = (factor == 1 ? 2 : 1);
 		int i = 0;
 
 		for(x = rmin; x < 0.95 * Math.pow(10, rminLog) && i < nticks;
 		    x += step, i++) {
 			ticks[i] = new Tick(x,range.toRelative(x,rangedVal), false);
 		}
 
 		double xlog = Math.round(rminLog);
 
 		for(; xlog < rminLLog - 0.1 && i < nticks; xlog += tickFactorLog) {
 			x = Math.pow(10, xlog);
 			ticks[i++] = new Tick(x,range.toRelative(x,rangedVal), true, "");
 
 			if(minorTicksDrawn) {
 				step = factor * x;
 				x = (factor == 1 ? x + step : step);
 
 				for(int k = kmin; k < kmax && i < nticks;
 				    k++, i++, x += step) {
 					ticks[i] = new Tick(x,range.toRelative(x,rangedVal), false);
 				}
 			}
 		}
 
 		int p = (int)Math.round(tickFactorLLog / tickFactorLog);
 		xlog = Math.round(rminLLog);
 
 		for(; i < nticks; xlog += tickFactorLog) {
 			x = Math.pow(10, xlog);
 
 			if(p == Math.round(tickFactorLLog / tickFactorLog)) {
 				ticks[i++] = new Tick(x,range.toRelative(x,rangedVal), true,
 						measurer.formatNumber(x));
 				p = 1;
 			} else {
 				ticks[i++] = new Tick(x,range.toRelative(x,rangedVal), true, "");
 				p++;
 			}
 
 			if(minorTicksDrawn) {
 				step = factor * x;
 				x = (factor == 1 ? x + step : step);
 
 				for(int k = kmin; k < kmax && i < nticks;
 				    k++, i++, x += step) {
 					ticks[i] = new Tick(x,range.toRelative(x,rangedVal), false);
 				}
 			}
 		}
 
 		if(boundTicksVisible) {
 			Tick[] ticks2 = new Tick[nticks + 2];
 			//unlabelled
 			ticks2[0] = new Tick(min,0, true, "");
 
 			for(i = 1; i <= nticks; i++) {
 				ticks2[i] = ticks[i - 1];
 			}
 			//unlabelled
 			ticks2[i] = new Tick(max, 1, true, "");
 			return ticks2;
 		}
 
 		return ticks;
 	}
 
 	private Tick[] onlyOneTick(double x, boolean boundVisible, double min, double max, Range range, RangedValue rangedVal)
 	{
 		Tick[] ticks = (boundVisible ? new Tick[3] : new Tick[1]);
 
 		if(boundVisible) {
 			ticks[0] = new Tick(min,range.toRelative(min,rangedVal), true, "");
 			ticks[1] = new Tick(x,range.toRelative(x,rangedVal), false);
 			ticks[2] = new Tick(max,range.toRelative(max,rangedVal), true, "");
 
 			return ticks;
 		}
 
 		ticks[0] = new Tick(x,range.toRelative(x,rangedVal), false);
 
 		return ticks;
 	}
 
 	private double logg(double x)
 	{
 		return Math.log(x) / Math.log(10);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.range2.TickCalculator#calculateTicks(int, 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.4g"), range, rangedValue);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.range2.TickCalculator#calculateTicks(int, 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__ */