// TimeTestApplet
// Ross Finlayson

import vrml.external.*;
import vrml.external.field.*;
import java.awt.*;
import java.applet.Applet;

public class TimeTestApplet extends Applet implements EventOutObserver{

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;
String timedeltaminimumstring, timestampdeltaminimumstring, timedeltamaximumstring, timestampdeltamaximumstring;
String timespanminimumstring, timestampspanminimumstring, timespanmaximumstring, timestampspanmaximumstring;

Button secondsbutton, millisecondsbutton, startbutton, detailbutton;

Browser browser;
Node timenode;
EventOutSFTime eventoutsftime;

EventInSFTime starttime;
EventInSFTime stoptime;

boolean started=true;
boolean first=true;

int accuracy=1;
int comprehensiveness=0;

long javatimeseconds, previoustimeseconds;

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 void init(){

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("Sample 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("Sample 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();
}

Panel timepanel;
Panel deltapanel, frequencypanel;
Panel deltafieldspanel, deltaplotpanel;
Panel frequencyfieldspanel, frequencyplotpanel;
Panel buttonpanel;

CardLayout deltacardlayout, frequencycardlayout;

timepanel=new Panel();

deltapanel=new Panel();
deltafieldspanel=new Panel();
deltaplotpanel=new Panel();

frequencypanel=new Panel();
frequencyfieldspanel=new Panel();
frequencyplotpanel=new Panel();

buttonpanel=new Panel();

timepanel.setLayout(new GridLayout(2,3));
deltafieldspanel.setLayout(new GridLayout(4,3));
frequencyfieldspanel.setLayout(new GridLayout(4,3));
buttonpanel.setLayout(new GridLayout(1,3));

timepanel.add(javatimelabel);
timepanel.add(vrmltimelabel);
timepanel.add(vrmltimestamplabel);
timepanel.add(javatimefield);
timepanel.add(vrmltimefield);
timepanel.add(vrmltimestampfield);

deltafieldspanel.add(deltalabel);
deltafieldspanel.add(timedeltafield);
deltafieldspanel.add(timestampdeltafield);

deltafieldspanel.add(minimumlabel);
deltafieldspanel.add(timedeltaminimumfield);
deltafieldspanel.add(timestampdeltaminimumfield);

deltafieldspanel.add(averagelabel);
deltafieldspanel.add(timedeltaaveragefield);
deltafieldspanel.add(timestampdeltaaveragefield);

deltafieldspanel.add(maximumlabel);
deltafieldspanel.add(timedeltamaximumfield);
deltafieldspanel.add(timestampdeltamaximumfield);

frequencyfieldspanel.add(spanlabel);
frequencyfieldspanel.add(timespanfield);
frequencyfieldspanel.add(timestampspanfield);

frequencyfieldspanel.add(minimumspanlabel);
frequencyfieldspanel.add(timespanmaximumfield);
frequencyfieldspanel.add(timestampspanmaximumfield);

frequencyfieldspanel.add(averagespanlabel);
frequencyfieldspanel.add(timespanaveragefield);
frequencyfieldspanel.add(timestampspanaveragefield);

frequencyfieldspanel.add(maximumspanlabel);
frequencyfieldspanel.add(timespanminimumfield);
frequencyfieldspanel.add(timestampspanminimumfield);

buttonpanel.add(detailbutton);
buttonpanel.add(secondsbutton);
buttonpanel.add(startbutton);


GridBagLayout gbl=new GridBagLayout();
setLayout(gbl);
constrain(this, timepanel, 0,0,3,2, GridBagConstraints.BOTH, GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
constrain(this, deltafieldspanel, 0,2,3,4, GridBagConstraints.BOTH, GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
constrain(this, deltaplotpanel, 0,6,3,4, GridBagConstraints.BOTH, GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
constrain(this, frequencyfieldspanel,0,10,3,4, GridBagConstraints.BOTH, GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
constrain(this, frequencyplotpanel,0,14,3,4, GridBagConstraints.BOTH, GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
constrain(this, buttonpanel, 0,18,3,1, GridBagConstraints.BOTH, GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);

// pack
doLayout();
/*
deltacardlayout=new CardLayout();
deltapanel.setLayout(deltacardlayout);
deltacardlayout.addLayoutComponent("fields", deltafieldspanel);
deltacardlayout.addLayoutComponent("plot", deltaplotpanel);
deltacardlayout.show(deltapanel, "fields");

frequencycardlayout=new CardLayout();
frequencypanel.setLayout(frequencycardlayout);
frequencycardlayout.addLayoutComponent("fields",deltafieldspanel);
frequencycardlayout.addLayoutComponent("plot", deltaplotpanel);
frequencycardlayout.show(frequencypanel, "fields");

remove(deltafieldspanel);
constrain(this, deltapanel, 0,2,3,4, GridBagConstraints.BOTH, GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
remove(frequencyfieldspanel);
constrain(this, frequencypanel,0,6,3,4, GridBagConstraints.BOTH, GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);

doLayout();

int deltapanelwidth, deltapanelheight;
int frequencypanelwidth, frequencypanelheight;
deltapanelwidth=deltafieldspanel.size().width;
deltapanelheight=deltafieldspanel.size().height;
frequencypanelwidth=frequencyfieldspanel.size().width;
frequencypanelheight=frequencyfieldspanel.size().height;

System.out.println("dw"+deltapanelwidth+"dh"+deltapanelheight+"fw"+frequencypanelwidth+"fh"+frequencypanelheight);

//deltacanvas=new TimeTestDeltaCanvas(this, deltapanelwidth, deltapanelheight);
//frequencycanvas=new TimeTestFrequencyCanvas(this, frequencypanelwidth, frequencypanelheight);

//deltaplotpanel.add(deltacanvas);
//frequencyplotpanel.add(frequencycanvas);
*/
}

private void constrain(Container container, Component component, int gridx, int gridy, int gridwidth, int gridheight, int fill, int anchor, double weightx, double weighty, int top, int left, int bottom, int right){
	GridBagConstraints c= new GridBagConstraints();
	c.gridx=gridx;
	c.gridy=gridy;
	c.gridwidth=gridwidth;
	c.gridheight=gridheight;
	c.fill=fill;
	c.anchor=anchor;
	c.weightx=weightx;
	c.weighty=weighty;
	if (top+bottom+left+right>0){c.insets=new Insets(top, left, bottom, right);}
	( (GridBagLayout) container.getLayout()).setConstraints(component, c);
	container.add(component);
}

public void start(){
try{
browser=Browser.getBrowser(this);
timenode=browser.getNode("TIMENODE");
eventoutsftime=(EventOutSFTime) timenode.getEventOut("time");
eventoutsftime.advise(this, null);
} catch (NullPointerException npe){vrmltimefield.setText("Null VRML Browser.  Reload/restart.");brake();}
 catch (UnsatisfiedLinkError ule){vrmltimefield.setText("Null VRML Browser.  Reload/restart.");brake();}

}

public void brake(){
detailbutton.disable();
secondsbutton.disable();
startbutton.disable();
}

public boolean handleEvent(Event event){

if (event.id==Event.ACTION_EVENT){

if (event.target==secondsbutton) accuracyAction();
if (event.target==startbutton) {if (started==false) {startTime();} else {stopTime();} }
if (event.target==detailbutton){detailAction();}
updateStats();
}

return true;
}

public void startTime(){

//EventInSFTime 
starttime=(EventInSFTime)timenode.getEventIn("set_startTime");
// get expected maximum VRML time
double currenttime=(double) ((System.currentTimeMillis()/1000) +(maximumtimestampdelta));

starttime.setValue(currenttime);

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

public void stopTime(){

//EventInSFTime 
stoptime=(EventInSFTime)timenode.getEventIn("set_stopTime");
// get balanced VRML time
double currenttime=(double) ((System.currentTimeMillis()/1000) +(maximumtimestampdelta));
stoptime.setValue(currenttime);

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(){

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

//TextField[] vrmltimefield, vrmltimestampfield, javatimefield;
//8


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 synchronized void callback(EventOut value, double timestamp, Object data){

javatime=System.currentTimeMillis();
javadoubletime=(double)(javatime/1000);
//System.out.println("Java double time"+javadoubletime+" "+javatime/1000.00);
vrmltime=eventoutsftime.getValue();
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.0000001;
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;
javatimeseconds=javatime/1000;

if(javatimeseconds>previoustimeseconds){
previoustimeseconds=javatimeseconds;
javatimestring=""+javatimeseconds;
javatimefield.setText(javatimestring);

}

timedeltastring=""+timedelta;
timestampdeltastring=""+timestampdelta;
timedeltaaveragestring=""+timedeltaaverage;
timestampdeltaaveragestring=""+timestampdeltaaverage;

vrmltimefield.setText(vrmltimestring);
vrmltimestampfield.setText(vrmltimestampstring);
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-(long)javatime;
long timestampdeltalong=vrmllongtimestamp-(long)javatime;

javatimestring=""+javatime;
javatimefield.setText(javatimestring);

vrmltimestring=""+vrmllongtime;
vrmltimestampstring=""+vrmllongtimestamp;
timedeltastring=""+timedeltalong;
timestampdeltastring=""+timestampdeltalong;
timedeltaaveragestring=""+(long)(timedeltaaverage*1000);
timestampdeltaaveragestring=""+(long)(timestampdeltaaverage*1000);
vrmltimefield.setText(vrmltimestring);
vrmltimestampfield.setText(vrmltimestampstring);
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);
}
}