import java.util.*;

/**
  * TimeCalc populates a TimeGrid object, passes it back to the observer,
  * and then sleeps for the specified time before repeating the process.
  */
public class TimeCalc implements Runnable {
	private Thread	calcThread;		// thread for this object
	private long 	startTime; 		// ms offset from 1/1/1970
	private long 	delay;			// delay between recalcs in ms
	private DialClockFrame 	callbackObj; // Object who's update() method should
									     // be called when new data is avail

	/**
	  * Contructor that takes a starting time in milliseconds offset from
	  * Jan 1, 1970, a delay in millis to wait before recalculating and 
	  * a DialClockFrame object to notify when new data is available.  A
	  * thread is started in this object.
	  */
	public TimeCalc(long startTime, long delay, DialClockFrame callbackObj) {
		this.startTime = startTime;
		this.delay = delay;
		this.callbackObj = callbackObj;

		// start a thread of execution for this object (use getThread()) to
		// stop it
		calcThread = new Thread(this);
		calcThread.start();
	}

	/** 
	  * Used to get the thread in TimeCalc object (usually to stop() it).
	  */
	public Thread getThread() {
		return calcThread;
	}

	/**
	  *  Main loop of thread running for this object, called indirectly
	  *  by the constructors call to start().  Should not be called directly.
	  */
	public void run() {
		long initTime   = System.currentTimeMillis(); // note when first run
		long offsetTime, nowWithMilli, nowNoMilli;
		Date lastMinD, lastHrD, lastDayD;
		TimeGrid tg;

		while ( true ) {
			// We don't have to show the current system time, but we are
			// running from a starting time specified in the constructor
			// requiring the need to calculate the current time offset since
			// this was first run.

			// calc how many millis have elapsed since run was first called
			offsetTime = System.currentTimeMillis() - initTime;
			nowWithMilli = startTime + offsetTime;

			// truncate all the milliseconds
			nowNoMilli= (long)Math.floor(nowWithMilli / 1000.0) * 1000;

			lastMinD 	= new Date(nowNoMilli);
			lastHrD 	= new Date(nowNoMilli);
			lastDayD 	= new Date(nowNoMilli);

			// find the start of this minute
			lastMinD.setSeconds(0);  

			// find the start of this hour
			lastHrD.setSeconds(0);
			lastHrD.setMinutes(0);

			// find the start of this day
			lastDayD.setSeconds(0);
			lastDayD.setMinutes(0);
			lastDayD.setHours(0);

			tg			= new TimeGrid();

			// calc seconds and minutes in this minute
			tg.cSecInMin = ( nowWithMilli - lastMinD.getTime() ) / 1000.0;
			tg.tSecInMin = 60.0;
			tg.cMinInMin = tg.cSecInMin / tg.tSecInMin;
			tg.tMinInMin = 1.0;

			// calc seconds, minutes, and hours in this hour
			tg.cSecInHr = ( nowWithMilli - lastHrD.getTime() ) / 1000.0;
			tg.tSecInHr = 60.0 * tg.tSecInMin;
			tg.cMinInHr = tg.cSecInHr / tg.tSecInMin;
			tg.tMinInHr = tg.tSecInHr / tg.tSecInMin;
			tg.cHrInHr 	= tg.cSecInHr / tg.tSecInHr;
			tg.tHrInHr 	= 1.0;

			// calc seconds, minutes, hours, and days in this day
			tg.cSecInDay = ( nowWithMilli - lastDayD.getTime() ) / 1000.0;
			tg.tSecInDay = 24.0 * tg.tSecInHr;
			tg.cMinInDay = tg.cSecInDay / tg.tSecInMin;
			tg.tMinInDay = tg.tSecInDay / tg.tSecInMin;
			tg.cHrInDay	 = tg.cSecInDay / tg.tSecInHr;
			tg.tHrInDay	 = tg.tSecInDay / tg.tSecInHr;
			tg.cDayInDay = tg.cSecInDay / tg.tSecInDay;
			tg.tDayInDay = 1.0;

			// pass back this TimeGrid object to the DialClockFrame that
			// wanted to know when we had new info
			callbackObj.update(tg);

			// take a nap for the specified delay --don't want to 
			// suck up all the CPU
			try { Thread.sleep(delay); } 
			catch (InterruptedException ignored) { break; }
		}

	} 
}