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 Knn_ST test
 */
public class Knn_ST extends SimpleMethod implements Method, Runnable
{
    // Members
    Knn_STTimeParameters parameters;
    Knn_STTimeParametersViewer parametersViewer;
    Database database;
    Results results;
    GeoRectangle geoRectangle = null;     // Geotools geoRectangle
    
    // Methods
    public static void main(String args[]){
        Knn_ST knn_st = new Knn_ST();
        knn_st.run();
    }
    
    public Knn_ST(){
	parameters = new Knn_STTimeParameters();
	parametersViewer = new Knn_STTimeParametersViewer(parameters);

    }
    public String toString() {return "Knn_ST";}
    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 J_k = 0, J_k2 = 0;
        int nge = 0;

	results = new Results();
	int k = parameters.getK();
	int numRuns = parameters.getNumRuns();
        MyPoint p;

        double stat = (double) 0.0;
        System.out.println(""+this+" "+significanceTest);
        if(geoRectangle==null) geoRectangle=database.getBounds();
	GeoData gcases = database.getCaseVals();
        Vector points = database.getPoints();

	int no_points = gcases.getSize();
        // double space[][] = new double[no_points][no_points];
        double space[] = new double[no_points];
        // double time[][] = new double[no_points][no_points];
        double time[] = new double[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];
	double dist_s[] = new double[no_points];
	double dist_t[] = new double[no_points];
        int indic[] = new int[no_points];
        int perm[] = new int[no_points];
        int ntimes, mm;

	// find the k shortest distances 
	for (int i=0; i<no_points; i++){
            from = ((MyPoint)points.elementAt(i)).cases;
	    p = (MyPoint)points.elementAt(i);
	    for(int j=0; j<no_points; j++){
                from1 = ((MyPoint)points.elementAt(j)).cases;
		if (i!=j){
		    dist_s[j] = p.dist((MyPoint)points.elementAt(j));
		    // space[i][j] = dist_s[j];
		    space[j] = dist_s[j];
                    // time[i][j] = Math.abs(from1 - from);
                    time[j] = Math.abs(from1 - from);
		    // dist_t[j] = time[i][j];
		    dist_t[j] = time[j];
		}
		else{
		    dist_s[j] = Double.POSITIVE_INFINITY;
		    // space[i][j] = 0.;
		    space[j] = 0.;
		    dist_t[j] = Double.POSITIVE_INFINITY;
		}
	    }
            double top_s[] = new double[k];
            double top_t[] = new double[k];
            for(int kk=0;kk<k;kk++){
                top_s[kk]=Double.POSITIVE_INFINITY;
                int index=-1;
                for(int j=0; j<no_points; j++){
                    if(top_s[kk]>dist_s[j]){
                        top_s[kk]=dist_s[j];
                        index=j;
                    }
                }
                dist_s[index]=Double.POSITIVE_INFINITY;
// System.out.println("Top " + i +" "+ kk +" "+ top_s[kk]);
            }
            for(int kk=0;kk<k;kk++){
                top_t[kk]=Double.POSITIVE_INFINITY;
                int index=-1;
                for(int j=0; j<no_points; j++){
                    if(top_t[kk]>dist_t[j]){
                        top_t[kk]=dist_t[j];
                        index=j;
                    }
                }
                dist_t[index]=Double.POSITIVE_INFINITY;
// System.out.println("Top " + i +" "+ kk +" "+ top_t[kk]);
            }
	    for (int j=i+1; j<no_points; j++){
                // s[i][j] = (space[i][j] <= top_s[k-1] ? 1 : 0);
                s[i][j] = (space[j] <= top_s[k-1] ? 1 : 0);
                // t[i][j] = (time[i][j] <= top_t[k-1] ? 1 : 0);
                t[i][j] = (time[j] <= top_t[k-1] ? 1 : 0);
                J_k += s[i][j] * t[i][j];
            }
	}
System.out.println("J_k = " + J_k);

// 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];
            t[j][i] = t[i][j];
        }

// Ok lets permute rows/columns of t
        // numRuns = 9; // just for the moment!
        for (int kk=0; kk<numRuns; kk++){
            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++;
                }
            }
            J_k2 = 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]];
                J_k2 += s[i][j] * t2[i][j];
            }
        // System.out.println("J_k2 = " + J_k2);
        if (J_k2 >= J_k) nge++;
        }
    System.out.println("Prob. of such a result is less than, or equal to " + (double) (nge+1)/(numRuns+1));
    }
}