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

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

    }
    public String toString() {return "Mantel";}
    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;
	double r = 0., r2 = 0.;
	int nge = 0;

	results = new Results();
	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();
	int np = no_points * (no_points - 1) / 2;
	double space[][] = new double[no_points][no_points];
	double time[][] = new double[no_points][no_points];
	double t2[][] = new double[no_points][no_points];
	int indic[] = new int[no_points];
	int perm[] = new int[no_points];
	int ntimes, mm;
	double ssum = 0., tsum = 0., ssq = 0., tsq = 0.;
	double smean = 0., tmean = 0., ssd = 0., tsd = 0.;

	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));
		ssum += space[i][j];
		ssq += space[i][j]*space[i][j];
		time[i][j] = Math.abs(from1 - from);
		tsum += time[i][j];
		tsq += time[i][j]*time[i][j];
	    }
// System.out.println(x +" "+ y +" "+ from +" "+ to);
// System.out.println(i +" "+ space[i][no_points-1] +" "+ time[i][no_points-1]);
	}
	smean = ssum / np;
	ssd = Math.sqrt((ssq - np*smean*smean) / (np-1));
	tmean = tsum / np;
	tsd = Math.sqrt((tsq - np*tmean*tmean) / (np-1));
// System.out.println(ssum +" "+ ssq +" "+ tsum +" "+ tsq);
// System.out.println(smean +" "+ ssd +" "+ tmean +" "+ tsd);

	for (int i=0; i<no_points; i++)
	for (int j=i+1; j<no_points; j++){
	    r += (space[i][j] - smean) * (time[i][j] - tmean);
	}
	r *= 2. / (ssd * tsd *(no_points*no_points - no_points - 1));
System.out.println("r = " + r);

// 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++){
	    time[j][i] = time[i][j];
	}

// 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++;
		}
	    }
	    r2 = 0;
	    for (int i=0; i<no_points; i++)
	    for (int j=i+1; j<no_points; j++){
		t2[i][j] = time[perm[i]][perm[j]];
                r2 += (space[i][j] - smean) * (t2[i][j] - tmean);
	    }
	    r2 *= 2. / (ssd * tsd *(no_points*no_points - no_points - 1));
// System.out.println("r2 = " + r2);
	    if (r2 >= r) nge++;
	}
    System.out.println("Prob. of such a result is less than, or equal to " + (double) (nge+1)/(numRuns+1));

    }
}