// TimeTestApplet
// Ross Finlayson

import java.awt.*;

public class TimeTestFrame extends Frame{

Label vrmltimelabel, vrmltimestamplabel, javatimelabel;
Label deltalabel, minimumlabel, maximumlabel, averagelabel;
Label spanlabel, minimumspanlabel, maximumspanlabel, averagespanlabel;

TextField vrmltimefield, vrmltimestampfield, javatimefield;
TextField timedeltafield, timestampdeltafield, timedeltaminimumfield, timestampdeltaminimumfield; 
TextField timedeltamaximumfield, timestampdeltamaximumfield, timedeltaaveragefield, timestampdeltaaveragefield;
TextField timespanfield, timestampspanfield, timespanminimumfield, timestampspanminimumfield; 
TextField timespanmaximumfield, timestampspanmaximumfield, timespanaveragefield, timestampspanaveragefield;

String vrmltimestring, vrmltimestampstring, javatimestring;
String timedeltastring, timestampdeltastring, timedeltaaveragestring, timestampdeltaaveragestring;
String timespanstring, timestampspanstring, timespanaveragestring, timestampspanaveragestring;

Button secondsbutton, millisecondsbutton, startbutton, detailbutton;

TimeTestFrameCallback script;

boolean started=true;
boolean first=true;

int accuracy=1;
int comprehensiveness=0;

double timedeltaaverage=0.0;
double timestampdeltaaverage=0.0;

double previoustime, previoustimestamp=Double.NaN;

double timespanaverage=0.0;
double timestampspanaverage=0.0;

long javatime;
double javadoubletime;

double vrmltime;
double vrmltimestamp;

double timedelta=0.0;
double timestampdelta=0.0;

double timespan=0.0;
double timestampspan=0.0;

double samplesize=0.0;
double samplesizeminusone=-1.0;

double maximumtimedelta, maximumtimestampdelta=Double.NEGATIVE_INFINITY;
double minimumtimedelta, minimumtimestampdelta=Double.POSITIVE_INFINITY;
double maximumtimespan, maximumtimestampspan=Double.NEGATIVE_INFINITY;
double minimumtimespan, minimumtimestampspan=Double.POSITIVE_INFINITY;


public static int TIME_MILLISECOND=0;
public static int TIME_SECOND=1;

public TimeTestFrame(TimeTestScript timetestscript){
super("VRML Time");
script=(TimeTestFrameCallback)timetestscript;
setBackground(Color.white);

vrmltimelabel=new Label("VRML Time:");
javatimelabel=new Label("Java Time:");
vrmltimestamplabel=new Label("VRML Timestamp:");
vrmltimefield=new TextField();
javatimefield=new TextField();
vrmltimestampfield=new TextField();

deltalabel=new Label("Delta:");
timedeltafield=new TextField();
timestampdeltafield=new TextField();

minimumlabel=new Label("Minimum Delta:");
timedeltaminimumfield=new TextField();
timestampdeltaminimumfield=new TextField();

maximumlabel=new Label("Maximum Delta:");
timedeltamaximumfield=new TextField();
timestampdeltamaximumfield=new TextField();

averagelabel=new Label("Average Delta:");
timedeltaaveragefield=new TextField();
timestampdeltaaveragefield=new TextField();

spanlabel=new Label("Frequency:");
timespanfield=new TextField();
timestampspanfield=new TextField();

minimumspanlabel=new Label("Minimum Frequency:");
timespanminimumfield=new TextField();
timestampspanminimumfield=new TextField();

maximumspanlabel=new Label("Maximum Frequency:");
timespanmaximumfield=new TextField();
timestampspanmaximumfield=new TextField();

averagespanlabel=new Label("Average Frequency:");
timespanaveragefield=new TextField();
timestampspanaveragefield=new TextField();

secondsbutton=new Button("Milliseconds");
startbutton=new Button("Stop");
detailbutton=new Button("Frequency");


vrmltimefield.disable();
vrmltimestampfield.disable();
javatimefield.disable();
TextField[] timetextfields= {timedeltafield, timestampdeltafield, timedeltaminimumfield, timestampdeltaminimumfield, timedeltamaximumfield, timestampdeltamaximumfield, timedeltaaveragefield, timestampdeltaaveragefield};
TextField[] frequencytextfields={timespanfield, timestampspanfield, timespanminimumfield, timestampspanminimumfield, timespanmaximumfield, timestampspanmaximumfield, timespanaveragefield, timestampspanaveragefield};
for (int i=0;i<8;i++){
timetextfields[i].disable();
frequencytextfields[i].disable();
}


setLayout(new GridLayout(11,3));

add(javatimelabel);
add(vrmltimelabel);
add(vrmltimestamplabel);
add(javatimefield);
add(vrmltimefield);
add(vrmltimestampfield);
add(deltalabel);
add(timedeltafield);
add(timestampdeltafield);
add(minimumlabel);
add(timedeltaminimumfield);
add(timestampdeltaminimumfield);
add(maximumlabel);
add(timedeltamaximumfield);
add(timestampdeltamaximumfield);
add(averagelabel);
add(timedeltaaveragefield);
add(timestampdeltaaveragefield);


add(spanlabel);
add(timespanfield);
add(timestampspanfield);
add(minimumspanlabel);

add(timespanmaximumfield);
add(timestampspanmaximumfield);

add(maximumspanlabel);

add(timespanminimumfield);
add(timestampspanminimumfield);

add(averagespanlabel);
add(timespanaveragefield);
add(timestampspanaveragefield);
add(detailbutton);
add(secondsbutton);
add(startbutton);

}


public boolean handleEvent(Event event){

switch (event.id){

case (Event.ACTION_EVENT):

if (event.target==secondsbutton) accuracyAction();
if (event.target==startbutton) {script.callback(this);}
if (event.target==detailbutton){detailAction();}

updateStats();
break;

case (Event.WINDOW_DESTROY):
hide();
}

return true;
}

public void startTime(){


//EventInSFTime 
startbutton.setLabel("Stop");
started=true;
}

public void stopTime(){
startbutton.setLabel("Start");
started=false;
}


public synchronized void accuracyAction(){

switch(accuracy){
case 0:
accuracy=1;
secondsbutton.setLabel("Milliseconds");
break;
case 1:
accuracy=0;
secondsbutton.setLabel("Seconds");
break;
}

}

public synchronized void detailAction(){

// 0 is frequency and time
// 1 is frequency
// 2 is time

switch(comprehensiveness){

case -1:
detailbutton.setLabel("Frequency");
comprehensiveness=0;
break;

case 0:
detailbutton.setLabel("Time");
comprehensiveness=1;
break;

case 1:
detailbutton.setLabel("None");
comprehensiveness=2;
break;

case 2:
detailbutton.setLabel("Frequency and Time");
comprehensiveness=-1;
break;

}




}


public void call(double time, double timestamp){


javatime=System.currentTimeMillis();
javadoubletime=(double)(javatime/1000);
//System.out.println("Java double time"+javadoubletime+" "+javatime/1000.00);
vrmltime=time;
vrmltimestamp=timestamp;

timedelta=vrmltime-javadoubletime;
timestampdelta=vrmltimestamp-javadoubletime;

samplesizeminusone=samplesize++;
//System.out.println("Sample size minus one:"+samplesizeminusone);

if (comprehensiveness==0 || comprehensiveness==2){

timedeltaaverage=((timedeltaaverage*samplesizeminusone+timedelta)/ samplesize);
timestampdeltaaverage=((timestampdeltaaverage*samplesizeminusone+timestampdelta)/ samplesize);

if (timedelta>maximumtimedelta) {maximumtimedelta=timedelta; updateStats();}
if (timestampdelta>maximumtimestampdelta) {maximumtimestampdelta=timestampdelta; updateStats();}
if (timedelta<minimumtimedelta) {minimumtimedelta=timedelta; updateStats();}
if (timestampdelta<minimumtimestampdelta) {minimumtimestampdelta=timestampdelta;updateStats();}
//timestampdeltaminimumfield.setText(""+minimumtimestampdelta); 

}

if (comprehensiveness==0 || comprehensiveness==1){

if (first){
if (previoustime==Double.NaN || previoustime==0.0){previoustime=vrmltime;System.out.println("Warning:  Double.NaN or zero.");}
if (previoustimestamp==Double.NaN || previoustimestamp==0.0){previoustimestamp=vrmltimestamp;System.out.println("Warning:  Double.NaN or zero.");}
}
//System.out.println("previous time:"+previoustime);
//System.out.println("vrml time:"+vrmltime);
timespan=vrmltime-previoustime;
timestampspan=vrmltimestamp-previoustimestamp;

//if (timespan<0.0){System.out.println("Negative.");}
//if (timestampspan<0.0){System.out.println("Negative stamp.");}
//if (timespan==0.0){System.out.println("Zero.");}
//if (timestampspan==0.0){System.out.println("Zero stamp.");}
//if (timespan==Double.MIN_VALUE){System.out.println("Minimal.");}
//if (timestampspan==Double.MIN_VALUE){System.out.println("Minimal stamp.");}
//System.out.println("debug2");
//updateStats();

timespanaverage=((timespanaverage*samplesizeminusone+timespan)/ samplesize);

if (first){
timestampspanaverage=0.0;
first=false;
}
else{
timestampspanaverage=((timestampspanaverage*samplesizeminusone+timestampspan)/ samplesize);
}

//System.out.println("timespan: "+timespan);
//System.out.println("timestampspan: "+timespan);
//System.out.println("timespanaverage: "+timespanaverage);
//System.out.println("timestampspanaverage: "+timestampspanaverage);

previoustime=vrmltime;
previoustimestamp=vrmltimestamp;

if (timespan>maximumtimespan) {maximumtimespan=timespan; updateStats();}
if (timestampspan>maximumtimestampspan) {maximumtimestampspan=timestampspan; updateStats();}
if (timespan<minimumtimespan) {minimumtimespan=timespan; updateStats();}
if (timestampspan<minimumtimestampspan) {minimumtimestampspan=timestampspan; updateStats();}
//timestampspanminimumfield.setText(""+minimumtimestampspan); 
}


if (comprehensiveness==0 || comprehensiveness==2){

switch(accuracy){

case 1:
timedelta=vrmltime-javadoubletime;
timestampdelta=vrmltimestamp-javadoubletime;

vrmltimestring=""+vrmltime;
vrmltimestampstring=""+vrmltimestamp;
javatimestring=""+javatime;
timedeltastring=""+timedelta;
timestampdeltastring=""+timestampdelta;
timedeltaaveragestring=""+timedeltaaverage;
timestampdeltaaveragestring=""+timestampdeltaaverage;

vrmltimefield.setText(vrmltimestring);
vrmltimestampfield.setText(vrmltimestampstring);
javatimefield.setText(javatimestring);
timedeltafield.setText(timedeltastring);
timestampdeltafield.setText(timestampdeltastring);
timedeltaaveragefield.setText(timedeltaaveragestring);
timestampdeltaaveragefield.setText(timestampdeltaaveragestring);

break;

case 0:
long vrmllongtime=(long)(vrmltime*1000.00f);
long vrmllongtimestamp=(long)(vrmltimestamp*1000.00f);
long timedeltalong=vrmllongtime-javatime;
long timestampdeltalong=vrmllongtimestamp-javatime;
vrmltimestring=""+vrmltime;
vrmltimestampstring=""+vrmltimestamp;
javatimestring=""+javatime;
timedeltastring=""+timedeltalong;
timestampdeltastring=""+timestampdeltalong;
timedeltaaveragestring=""+(long)(timedeltaaverage*1000);
timestampdeltaaveragestring=""+(long)(timestampdeltaaverage*1000);
vrmltimefield.setText(vrmltimestring);
vrmltimestampfield.setText(vrmltimestampstring);
javatimefield.setText(javatimestring);
timedeltafield.setText(timedeltastring);
timestampdeltafield.setText(timestampdeltastring);
timedeltaaveragefield.setText(timedeltaaveragestring);
timestampdeltaaveragefield.setText(timestampdeltaaveragestring);

}
//frequency


}

if (comprehensiveness==0 || comprehensiveness==1){

//System.out.println("timespan: "+timespan);
//System.out.println("timestampspan: "+timespan);
//System.out.println("timespanaverage: "+timespanaverage);
//System.out.println("timestampspanaverage: "+timestampspanaverage);


timespanstring=""+(1.00000f/timespan);
timestampspanstring=""+(1.00000f/timestampspan);
timespanaveragestring=""+(1.00000f/timespanaverage);
timestampspanaveragestring=""+(1.00000f/timestampspanaverage);
timespanfield.setText(timespanstring); 
timestampspanfield.setText(timestampspanstring);
timespanaveragefield.setText(timespanaveragestring);
timestampspanaveragefield.setText(timestampspanaveragestring);

}

}


public void updateStats(){ 
switch(accuracy){
case 0:
timedeltamaximumfield.setText(""+(long)(maximumtimedelta*1000));
timestampdeltamaximumfield.setText(""+(long)(maximumtimestampdelta*1000));
timedeltaminimumfield.setText(""+(long)(minimumtimedelta*1000));
timestampdeltaminimumfield.setText(""+(long)(minimumtimestampdelta*1000));
break;
case 1:
timedeltamaximumfield.setText(""+maximumtimedelta);
timestampdeltamaximumfield.setText(""+maximumtimestampdelta);
timedeltaminimumfield.setText(""+minimumtimedelta);
timestampdeltaminimumfield.setText(""+minimumtimestampdelta);
}
timespanmaximumfield.setText(""+1.00000/maximumtimespan);
timestampspanmaximumfield.setText(""+1.00000/maximumtimestampspan);
timespanminimumfield.setText(""+1.00000/minimumtimespan);
timestampspanminimumfield.setText(""+1.00000/minimumtimestampspan);
}
}