/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-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.
   *
   * Java-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 Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.util;
  
  import java.util.ArrayList;
  
  /**
   * @author <a href="mailto:gasper.pajor@cosylab.com">Gasper Pajor</a>
   * @version $id$
   *
   * this is temporary version of a tool that performs some tasks
   * with double[]; for the moment adding to array of fixed lenght 
   * and retrieving from such array is implemented.
   *
   */
  public class PrimitiveDoubleList {
  
  	public double[] primaryArray = null;
  	private int pStart;
  	private int pEnd;
  	private double[] secondaryArray = null;
  	private boolean growing = false;
  	private double[] compactArray = null;
  
  	/**
  	 * Constructor for PrimitiveDoubleList.
  	 */
  	public PrimitiveDoubleList(int initialSize, boolean grow) {
  		super();
  		growing = grow;
  		if (growing) {
  			primaryArray = new double[2 * initialSize];
  			//			secondaryArray = new double[2*initialSize];
  			pStart = 0;
  			pEnd = 0;
  		} else {
  			primaryArray = new double[initialSize + 1];
  			secondaryArray = new double[initialSize];
  
  		}
  
  	}
  
  	public int size() {
  		return pEnd - pStart;
  	}
  
  	public double[] getArray() {
  
  		if (growing) {
  
  			return compactGrowingArray(primaryArray, pStart, pEnd);
  
  		} else {
  
  			if (pStart < pEnd) {
  				System.arraycopy(
  					primaryArray,
  					pStart,
  					secondaryArray,
  					0,
  					(pEnd - pStart));
  			} else {
  				System.arraycopy(
  					primaryArray,
  					pStart,
  					secondaryArray,
  					0,
  					(primaryArray.length - pStart));
  				System.arraycopy(
  					primaryArray,
  					0,
  					secondaryArray,
  					(primaryArray.length - pStart),
  					pEnd);
  			}
  			return secondaryArray;
  		}
  
  	}
  
  	/**
 	 * Method compactGrowingArray.
 	 * @param array
 	 * @param start
 	 * @param end
 	 * @return double[]
 	 */
 	private double[] compactGrowingArray(double[] array, int start, int end) {
 
 		if ((compactArray==null) || (compactArray.length!=(end-start))) compactArray = new double[end - start];
 		System.arraycopy(array, start, compactArray, 0, end - start);
 
 		return compactArray;
 	}
 
 	public synchronized void addElement(double el) {
 
 		if (growing) {
 
 			if ((pEnd >= primaryArray.length - 1))
 				activeTooSmall();
 
 			primaryArray[pEnd] = el;
 			pEnd = (pEnd + 1);
 			//System.out.println("End set to "+pEnd);
 			//System.out.println("element added - value "+ (pEnd-1));
 
 		} else {
 
 			if (pStart == 0 && pEnd == 0) {
 				// array empty
 				primaryArray[pEnd] = el;
 				pEnd++;
 			} else if (pStart == 0 && pEnd != primaryArray.length - 1) {
 				// array not full yet, filling
 				primaryArray[pEnd] = el;
 				pEnd++;
 			} else if (pEnd == primaryArray.length - 1) {
 				primaryArray[pEnd] = el;
 				pEnd = 0;
 				pStart++;
 			} else if (pStart == primaryArray.length - 1) {
 				primaryArray[pEnd] = el;
 				pEnd++;
 				pStart = 0;
 			} else if (pEnd + 1 == pStart) {
 				primaryArray[pEnd] = el;
 				pEnd++;
 				pStart++;
 			}
 		}
 	}
 
 	/**
 	 * Method activeToSmall.
 	 */
 	private synchronized void activeTooSmall() {
 		//System.out.println("active to small! activeLength="+primaryArray.length+" secLength="+secondaryArray.length+" pStart="+pStart+" pEnd="+pEnd);
 
 		double[] tempArray;
 		if (2 * (pEnd - pStart + 1) > primaryArray.length) {
 			tempArray = new double[2 * (pEnd - pStart + 1)];
 			//System.out.println("new secondary (creation)! activeLength="+primaryArray.length+" tempLength="+tempArray.length+" pStart="+pStart+" pEnd="+pEnd);
 		} else
 			tempArray = primaryArray;
 		System.arraycopy(primaryArray, pStart, tempArray, 0, pEnd - pStart);
 		primaryArray = tempArray;
 		pEnd = pEnd - pStart;
 		pStart = 0;
 		//System.out.println("---new startStop! activeLength="+primaryArray.length+" tempLength="+tempArray.length+" pStart="+pStart+" pEnd="+pEnd);
 
 	}
 
 	public synchronized void removeOldest() {
 
 		if (pStart < pEnd)
 			pStart = pStart + 1;
 
 	}
 
 	public synchronized void removeOldest(int i) {
     if ((i<1) || (i>size()-1)) return;
 		if (pStart < pEnd)
 			if (pStart + i < pEnd) {
 				pStart = pStart + i;
 			} else
 				pStart = pEnd;
 
 	}
 	public double get(int index){
 		return primaryArray[pStart+index];
 	}
 	public void set(int index, double value){
 		if (pStart+index<pEnd)
 		primaryArray[pStart+index] = value;
 	}
 	
 	public double[] fillLatest(double[] arrayToFill) {
 
 		int i = arrayToFill.length;
 
 		if (i == pEnd - pStart)
 			System.arraycopy(primaryArray, pStart, arrayToFill, 0, i);
 		else if (i < pEnd - pStart)
 			System.arraycopy(primaryArray, pEnd - i, arrayToFill, 0, i);
 		else if (i > pEnd - pStart)
 			System.arraycopy(
 				primaryArray,
 				pStart,
 				arrayToFill,
 				i - (pEnd - pStart),
 				pEnd - pStart);
 		return arrayToFill;
 	}
 /**
  * 
  * Run test applet.
  * 
  * @param args command line parameters
  */
 	public static void main(String[] args) {
 
 		// this is demo.
 
 		PrimitiveDoubleList pdl = new PrimitiveDoubleList(6, true);
 		ArrayList al = new ArrayList(6);
 
 
 		/////////////////////////////////////////
 		/// ArrayList Vs. PrimitiveDoubleList ///
 		/////////////////////////////////////////
 
 		long aStart;
 		long aStop;
 		long bStart;
 		long bStop;
 		Double d = new Double(1);
 
 		// Arraylist does it
 		/////////////////////
 
 		aStart = System.currentTimeMillis();
 		for (int i = 0; i < 5000; i++) {
 			for (int j = 0; j < 8; j++) {
 				al.add(d);
 			}
 			for (int j = 0; j < 5; j++) {
 				al.remove(0);
 			}
 		}
 		aStop = System.currentTimeMillis();
 		System.out.println(
 			"ArrayList "
 				+ (aStop - aStart)
 				+ " milis, array lenght "
 				+ al.size());
 		bStart = System.currentTimeMillis();
 
 		// PrimitiveDoublelist does it
 		/////////////////////////////////
 
 		//pdl.addElement(-1);
 		//pdl.addElement(0);
 		for (int i = 0; i < 5000; i++) {
 			for (int j = 0; j < 8; j++) {
 				pdl.addElement(j);
 			}
 			for (int j = 0; j < 1; j++) {
 				pdl.removeOldest(5);
 			}
 		}
 		bStop = System.currentTimeMillis();
 
         System.out.println(
             "PrimitiveDoubleList "
                 + (bStop - bStart)
                 + " milis, array lenght "
                 + pdl.getArray().length
                 + " actual: "
                 + pdl.primaryArray.length);
 
 
 //////////////////
 
         ResizableDoubleList dl = new ResizableDoubleList(6);
 
         // New Doublelist does it
         /////////////////////////////////
 
         //pdl.addElement(-1);
         //pdl.addElement(0);
         for (int i = 0; i < 5000; i++) {
             for (int j = 0; j < 8; j++) {
                 dl.add(j);
             }
             for (int j = 0; j < 1; j++) {
                 dl.remove(0,5);
             }
         }
                 System.out.println(
             "ResizableDoubleList "
                 + (bStop - bStart)
                 + " milis, array lenght "
                 + dl.getArray().length
                 + " actual: "
                 + dl.getBufferArray().length);
 
 //////////////
 
 
 
 
 		System.out.println(
 			"I am better for "
 				+ 100
 					* ((aStop - aStart) - (bStop - bStart))
 					/ ((bStop - bStart))
 				+ " %");
 
 		////////////////////////
 		//test 2
 		////////////////////////
 
 		/*
 		System.out.println("Inserting 10 doubles");
 		
 		for (int i = 11; i < 60000; i++) {
 			pdl.addElement(i);
 			double[] tempA = pdl.getArray();
 			for (int j = 0; j < tempA.length; j++) {
 			//System.out.print(" "+tempA[j]);	
 			}
 			//System.out.println("");
 		}
 		System.out.println("\nremoving 3 oldest doubles");	
 		pdl.removeOldest(3);
 				
 			double[] tempA = pdl.getArray();
 			for (int j = 0; j < tempA.length; j++) {
 			System.out.print(" "+tempA[j]);	
 			}
 		System.out.println("\nretriving doubles");
 		tempA = new double[7];
 		pdl.fillLatest(tempA);	
 		
 			for (int j = 0; j < tempA.length; j++) {
 			System.out.print(" "+tempA[j]);	
 			}
 		*/
 	}
 
 }