/*
    * 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;
  
  import java.util.ArrayList;
  
  /**
   * <Code>ManualTickCalculator</code> calculates ticks explicitely. Ticks are calculated
   * according to the supplied parameters which define at which values major and minor
   * ticks should be.
   *   
   * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
   * @version $Id: ManualTickCalculator.java,v 1.4 2008-04-22 12:28:40 jbobnar Exp $
   *
   */
  public class ManualTickCalculator implements TickCalculator {
  
  	private double[] majorTicks = null;
  	private double[] labels = null;
  	private double minor = 0;
  	
  	/**
  	 * Constructs a new ManualTickProvider with null value.
  	 *
  	 */
  	public ManualTickCalculator() {
  		
  	}
  	
  	/**
  	 * Constructs a new ManualTickProvider with the given parameters.
  	 * 
  	 * @param majorTicks values that major ticks will be created for
  	 * @param labels values that will have labels (only major ticks can have labels).
  	 * @param minor number of minor ticks between two major ticks
  	 */
  	public ManualTickCalculator(double[] majorTicks, double[] labels, double minor) {
  		this.majorTicks = majorTicks;
  		this.labels = labels;
  		this.minor = minor;
  		
  	}
  	
  	/**
  	 * Sets the values that will have labels printed next to ticks. Only major ticks
  	 * can have labels.
  	 * 
  	 * @param labels
  	 */
  	public void setLabels(double[] labels) {
  		this.labels = labels;
  	}
  	
  	/**
  	 * Sets the values which will have major ticks.
  	 * 
  	 * @param majorTicks
  	 */
  	public void setMajorTicks(double[] majorTicks) {
  		this.majorTicks = majorTicks;
  	}
  	
  	/**
  	 * Sets the number of minor ticks between two major ticks.
  	 * 
  	 * @param minor
  	 */
  	public void setMinor(double minor) {
  		this.minor = minor;
  	}
  	
  	/**
  	 * Returns the values which have labels printed next to the ticks.
  	 * 
  	 * @return
  	 */
  	public double[] getLabels() {
  		return labels;
  	}
  	
  	/**
  	 * Returns the values which have major ticks.
 	 * 
 	 * @return
 	 */
 	public double[] getMajorTicks() {
 		return majorTicks;
 	}
 	
 	/**
 	 * Returns the number of minor ticks between two major ticks.
 	 * @return
 	 */
 	public double getMinor() {
 		return minor;
 	}
 		
 	private String getLabel(double d, TickParameters measurer) {
 		if (this.labels == null) return "";
 		for (int i = 0; i < labels.length; i++) {
 			if (labels[i] == d) return measurer.formatNumber(d); 
 		}
 		return "";
 	}
 	
 	/*
 	 * (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(), range, rangedValue);
 	}
 	
 	private double getMinimumMajorTick(double limit) {
 		if (majorTicks.length == 0) return Double.NaN;
 		double min = majorTicks[0];
 		for (int i = 1; i < majorTicks.length; i++) {
 			if (majorTicks[i] < limit) continue;
 			min = Math.min(min, majorTicks[i]);
 		}
 		return Math.max(min, limit);
 	}
 	
 	private double getMinorStep(double min, double max, int majorCount) {
 		if (minor != 0) return minor;
 		else if (majorCount == 0) return (max-min)/2.;
 		else return (max-min)/majorCount/5.;
 	}
 		
 	/*
 	 * (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 spaceLength, TickParameters measurer, Range range, RangedValue rangedValue) {
 		if (this.majorTicks == null || this.majorTicks.length == 0) return new Tick[0];
 		if (measurer == null) measurer = new DefaultTickParameters();
 		int length = majorTicks.length;
 		
 //		int num = (int)((rangedValue.getMaximum() - rangedValue.getMinimum())/minor);
 		double rMax = rangedValue.getMaximum();
 		double rMin = rangedValue.getMinimum();
 		double mMin = getMinimumMajorTick(rMin);
 		double minor = getMinorStep(rMin, rMax, length);
 		int num = (int)((rMax - mMin)/minor);
 		int n2 = 0;
 		if (rMin < mMin) {
 			n2 = (int)((mMin-rMin)/minor);
 		}
 		
 		ArrayList<Tick> ticks;
 		if (length + num + n2 < 0 || length + num + n2 > 1000000) {
 			throw new IllegalStateException("Number of minor ticks is too large. Adjust the minor step.");
 		} else {
 			ticks = new ArrayList<Tick>(length + num + n2);
 		}
 		
 		for (int i = n2 -1; i >= 0 ; i--) {
 			ticks.add(new Tick(mMin - (i+1)*minor, range.toRelative(mMin - (i+1)*minor, rangedValue), false, ""));
 		}
 		
 		for (int i = n2; i < n2 + num; i++) {
 			ticks.add(new Tick(mMin + (i-n2 + 1) *minor, range.toRelative(mMin + (i-n2 + 1)*minor, rangedValue), false, ""));
 		}
 		
 		for (int i = n2 + num; i < length + num + n2; i++) {
 			if (majorTicks[i - num - n2] > rMax || majorTicks[i - num - n2] < rMin) continue;
 			ticks.add(new Tick(majorTicks[i - num-n2], range.toRelative(majorTicks[i - num-n2], rangedValue), true, getLabel(majorTicks[i-num-n2], measurer)));
 		}
 		
 		return ticks.toArray(new Tick[ticks.size()]);
 	}
 	
 	public static void main(String[] args) {
 		double[] vals = new double[]{0,5,10,15};
 		double[] lab = new double[]{5,15};
 		ManualTickCalculator pr = new ManualTickCalculator(vals,lab,4);
 		Tick[] t = pr.calculateTicks(0, new LinearRange(), new RangedValue(0,15,3));
 		for (int i = 0; i < t.length; i++) {
 			System.out.println(t[i]);
 		}
 	}
 }