package uk.ac.leeds.ccg.cluster;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import uk.ac.leeds.ccg.geotools.*;

/** A class that implements Knox test 
 */
public class Knox extends SimpleMethod implements Method, Runnable
{
    // Members
    KnoxTimeParameters parameters;
    KnoxTimeParametersViewer parametersViewer;
    Database database;
    Results results;
    GeoRectangle geoRectangle = null;     // Geotools geoRectangle
    
    // Methods
    public static void main(String args[]){
        Knox knox = new Knox();
        knox.run();
    }
    
    public Knox(){
    	parameters = new KnoxTimeParameters();
        parametersViewer = new KnoxTimeParametersViewer(parameters);

    }
    public String toString() {return "Knox";}
    public Parameters getParameters() {return parameters;}
    public ParametersViewer getParametersViewer() {return parametersViewer;}
    public void setData(Database d) {database=d;}

    public SignificanceTest getSignificanceTest(){return significanceTest;}

    public void setSearch(GeoRectangle r) {geoRectangle=r;}
    public Results getResults(){return results;}
    
    public void run(){
	double to, from, x, y;
	double to1, from1, x1, y1;
	int X = 0, X2 = 0;
	int nge = 0;

	results = new Results();
	int delta = parameters.getDelta();
	int tau = parameters.getTau();
	int numRuns = parameters.getNumRuns();
	double thresh = parameters.getSignificanceThreshold();

        double stat = (double) 0.0;
        System.out.println(""+this+" "+significanceTest);
        GeoData gcases = database.getCaseVals();
	Vector points = database.getPoints();
	
	int no_points = gcases.getSize();
	// space & time made int, s & t removed - trying to save memory
	// double space[][] = new double[no_points][no_points];
	// double time[][] = new double[no_points][no_points];
	int space[][] = new int[no_points][no_points];
	int time[][] = new int[no_points][no_points];
	// int s[][] = new int[no_points][no_points];
	// int t[][] = new int[no_points][no_points];
	int t2[][] = new int[no_points][no_points];
	int indic[] = new int[no_points];
	int perm[] = new int[no_points];
	int ntimes, mm;

	for (int i=0; i<no_points; i++){
	    from = ((MyPoint)points.elementAt(i)).cases;
	    // to = ((MyPoint)points.elementAt(i)).pop;
	    x = ((MyPoint)points.elementAt(i)).x;
	    y = ((MyPoint)points.elementAt(i)).y;
	    for (int j=i+1; j<no_points; j++){
                from1 = ((MyPoint)points.elementAt(j)).cases;
                // to1 = ((MyPoint)points.elementAt(j)).pop;
                x1 = ((MyPoint)points.elementAt(j)).x;
                y1 = ((MyPoint)points.elementAt(j)).y;
		// space[i][j] = Math.sqrt( (x1-x)*(x1-x) + (y1-y)*(y1-y));
		// time[i][j] = Math.abs(from1 - from);
		space[i][j] = (int) (Math.sqrt( (x1-x)*(x1-x) + (y1-y)*(y1-y)) +0.99);
		time[i][j] = (int) (Math.abs(from1 - from) +0.99);
	    }
// System.out.println(x +" "+ y +" "+ from +" "+ to);
// System.out.println(i +" "+ space[i][no_points-1] +" "+ time[i][no_points-1]);
	}
	for (int i=0; i<no_points; i++)
	for (int j=i+1; j<no_points; j++){
	    // s[i][j] = (space[i][j] <= delta ? 1 : 0);
	    space[i][j] = (space[i][j] <= delta ? 1 : 0);
	    // t[i][j] = (time[i][j] <= tau ? 1 : 0);
	    time[i][j] = (time[i][j] <= tau ? 1 : 0);
	    // X += s[i][j] * t[i][j];
	    X += space[i][j] * time[i][j];
	}
System.out.println("X = " + X);

// To assess significance, a Monte Carlo type thing...
	for (int i=0; i<no_points; i++)
        for (int j=i+1; j<no_points; j++){
	    // s[j][i] = s[i][j];  is this line needed? NO :o)
	    // t[j][i] = t[i][j];
	    time[j][i] = time[i][j];
	}
        // for(int i=0;i<t.length;i++){
            // System.out.print("Orig: "); // row leader
            // for(int j=0;j<t[i].length;j++){
            // System.out.print(""+t[i][j]+"\t");
            // }
            // System.out.println(""); // start a new line for each row add any ro w end text
        // }

// Ok lets permute rows/columns of t
	// numRuns = 9; // just for the moment!
	for (int k=0; k<numRuns; k++){
	    ntimes = 0;
	    for (int i=0; i<no_points; i++) indic[i] = 0;
	    while (ntimes < no_points){
		mm = (int) (no_points * Math.random());
		if (indic[mm] == 0){
// System.out.println("ntimes, mm  " + ntimes +" "+ mm);
		    indic[mm] = 1;
		    perm[ntimes] = mm;
		    ntimes++;
		}
	    }
	    X2 = 0;
	    for (int i=0; i<no_points; i++)
	    for (int j=i+1; j<no_points; j++){
		// t2[i][j] = t[perm[i]][perm[j]];
		t2[i][j] = time[perm[i]][perm[j]];
                // X2 += s[i][j] * t2[i][j];
                X2 += space[i][j] * t2[i][j];
	    }
// System.out.println("perm: " + perm[0] + perm[1] + perm[2] + perm[3]+ perm[4] + perm[5]);
	    // for(int i=0;i<t2.length;i++){
      		// System.out.print("Perm: "); // row leader
		// for(int j=0;j<t2[i].length;j++){
		// System.out.print(""+t2[i][j]+"\t");
     		// }
     		// System.out.println(""); // start a new line for each row add any row end text
	    // }
	// System.out.println("X2 = " + X2);
	    if (X2 >= X) nge++;
	    if ( (double) (nge+1)/(numRuns+1) > thresh){
    	    	System.out.println("Will not be significant, nge = " + nge +","+ k +" out of NRuns");
    	    	break;
	    }
	}

	if ( (double) (nge+1)/(numRuns+1) > thresh) System.out.println("Prob. of such a result is greater than " + (double) (nge+1)/(numRuns+1));
        else System.out.println("Prob. of such a result is less than, or equal to " + (double) (nge+1)/(numRuns+1));

    }
}