import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.lang.*;
//import Jama.Matrix;

public class ViVA extends Frame 
  implements AdjustmentListener, ActionListener, MouseListener
{
  static char a;
  Cnode Cn;
  static int nc, nr;
  MSTgraph SD;
  gt2 GT2;
  Data1 Dt;
  Label lfactor, lnbhd, nsd;
  Label tspeed;
  int factor, nbhd, sd;
  TextField input1, input2, input3;  
  private PtCanvas1 c; 
  private Panel p, p2;
  Button MSTree, SusRes, Stop, Partition, DColor, PrintPartition;  
  static PopupMenu MSTdata;
  Scrollbar Speed;
  Font fo; 
  private double gp[][];
  double data[][];
  static boolean erase[];
  static int mst_count=0;
  static int nd = 2;
  double st = 0.1;
  static MenuItem function[];
  static String fn;
  PrintWriter pwriter;
  Color pcolor[];
  int aa=0;
  int nsta[], nend[];
  boolean nerase[];

  public ViVA(String filename)
  {
    fn = filename;
    Dt = new Data1();
    try{
    Dt.readData(filename); }
    catch(IOException e){ }
    nc = Dt.ncols;
    nr = Dt.nrows; 
    data = new double[Dt.nrows][Dt.ncols];
    GT2 = new gt2(nc,nr,nd,st); 
//    if (a=='Y') {
//     Standardize(Dt.x); 
//    }  
    GT2.raw_data = Dt.x;
//    Dt = null;
//    System.gc();
    gp = new double[nr][nc];
    fo = new Font("Courier",Font.BOLD, 13);
    setFont(fo);
    setLayout(new BorderLayout());
    c = new PtCanvas1();    add("Center",c);
    p = new Panel();   add(p, BorderLayout.SOUTH);
    GridBagLayout gbag=new GridBagLayout();
    GridBagConstraints cg=new GridBagConstraints();
    p.setLayout(gbag);
    tspeed=new Label("Tour Speed");
    Speed = new Scrollbar();
    Speed.setValues((int) 10, (int) 1, (int) 1, (int) 90);
    Speed.setOrientation((int) Speed.HORIZONTAL);
    System.out.println("Orient="+Speed.getOrientation());
    MSTree = new Button("Draw MST");
    SusRes = new Button("Suspend/Resume");
    Partition = new Button("Make Partition");
    DColor = new Button("Color Partition");
    PrintPartition= new Button("Print Partition");
    Stop = new Button("Quit");
    MSTdata = new PopupMenu();
    function = new MenuItem[7];
    
    function[0]=new MenuItem("From Points");
    function[1]=new MenuItem("From Results");
    for (int i=0; i<2; i++){
     MSTdata.add(function[i]);
     function[i].addActionListener(this);
    }
    p2=new Panel();
    p2.setLayout(new GridLayout(1,6));
    lfactor=new Label("Input Factor");
    lnbhd=new Label("Input Neighborhood Size");
    nsd=new Label("Input Multiples of S.D.");
    p2.add(lfactor);
    input1 = new TextField(2);
    p2.add(input1);
    p2.add(lnbhd);
    input2 = new TextField(2);
    p2.add(input2);
    p2.add(nsd);
    input3 = new TextField(2);
    p2.add(input3);
    input1.addActionListener(this);
    input2.addActionListener(this);
    input3.addActionListener(this);
    Speed.addAdjustmentListener(this);
    MSTree.addActionListener(this);
    MSTree.add(MSTdata);
    SusRes.addActionListener(this);
    Partition.addActionListener(this);
    PrintPartition.addActionListener(this);
    DColor.addActionListener(this);
    Stop.addActionListener(this);
    cg.weightx=1.0;
    gbag.setConstraints(MSTree,cg);
    gbag.setConstraints(SusRes,cg);
    gbag.setConstraints(Partition,cg);
    gbag.setConstraints(DColor,cg);
    gbag.setConstraints(PrintPartition,cg);
    cg.gridwidth=GridBagConstraints.REMAINDER;
    gbag.setConstraints(Stop,cg);
    cg.gridwidth=GridBagConstraints.REMAINDER;
    gbag.setConstraints(p2,cg);
    cg.gridwidth=1;
    gbag.setConstraints(tspeed,cg);
    cg.gridwidth=GridBagConstraints.REMAINDER;
    cg.fill=GridBagConstraints.BOTH;
    gbag.setConstraints(Speed,cg);
    p.add(MSTree); 
    p.add(SusRes); 
    p.add(Partition);
    p.add(DColor);
    p.add(PrintPartition);
    p.add(Stop);
    p.add(p2);
    p.add(tspeed);
    p.add(Speed); 
  }


  public void adjustmentValueChanged(AdjustmentEvent evt)
  {
    System.out.println("evt.getValue="+evt.getValue());
    st = (double)evt.getValue()/100.0;
  }

  public void actionPerformed(ActionEvent evt) 
  {
    if (evt.getSource() == SusRes ) 
      c.Sus_Res();  
    else if (evt.getSource() == MSTree) 
      c.MinimalSpanning_Tree();
    else if (evt.getSource() == Partition){
    }
    else if (evt.getSource() == input1){ 
      factor=Integer.parseInt(input1.getText());
      System.out.println(factor);
    }
    else if (evt.getSource() == input2)
      nbhd=Integer.parseInt(input2.getText());
    else if (evt.getSource() == input3)
      sd=Integer.parseInt(input3.getText());
    else if (evt.getSource() == DColor){
      nsta=new int[nr+1];
      nend=new int[nr+1];
      nerase=new boolean[nr+1];
      for (int i=0;i<nr-1;i++){
       nsta[i]=SD.sta[i]+1; nend[i]=SD.end[i]+1; nerase[i]=erase[i];
      }
      SD.AsortPoints(nsta,nend,nerase,nr-1);

     for (int i=nr-1; i>=1; i--){
      nsta[i]=nsta[i-1]; nend[i]=nend[i-1]; nerase[i]=nerase[i-1]; }

//      Cn = new Cnode();
      Cn.node = new int[nr+1];
      Cn.ComputeNode(nend,nr);
      int max; max=Cn.node[1];
      for (int i=2; i<=nr; i++)
        if (Cn.node[i] >= max) max=Cn.node[i];
      Cn.ComputeNode1(nend,nr,max);
      Cn.Label(nend,nr,nerase,max);
     aa=1;
     pcolor = new Color[nr];
     for (int i=0; i< nr; i++){
      switch ((int) Cn.label[i+1]){
       case 1: pcolor[i]=Color.red; break;
       case 2: pcolor[i]=Color.yellow; break;
       case 3: pcolor[i]=Color.green; break;
       case 4: pcolor[i]=Color.magenta; break;
       case 5: pcolor[i]=Color.orange; break;
       case 6: pcolor[i]=Color.pink; break;
       case 7: pcolor[i]=Color.white; break;
       case 8: pcolor[i]=Color.blue; break;
       case 9: pcolor[i]=Color.blue.brighter(); break;
       default:  pcolor[i]= Color.cyan; break;
      }
     }
    }
    else if (evt.getSource() == PrintPartition){
      String fn_class = ViVA.fn.concat(".class");
      try{
       FileOutputStream fl=new FileOutputStream(fn_class);
       DataOutputStream out=new DataOutputStream(fl);
       pwriter = new PrintWriter(out,true);
      } catch(IOException e){System.exit(1);}
     for (int i=1; i<nr; i++) {
      pwriter.print(nend[i]+" ");
      if (!nerase[i]) pwriter.println("1");
      if (nerase[i]) pwriter.println("0"); 
//      pwriter.println(Cn.label[i]);
      
     }
    }
    else if (evt.getSource() == function[0]){
      try{
      c.MenuShow(0);} catch (IOException e){ };
    }
    else if (evt.getSource() == function[1]){
      try{
      c.MenuShow(1);} catch (IOException e){ };
    }
    else if (evt.getSource() == Stop)
      System.exit(0);
  }

  public void mouseClicked(MouseEvent e){ }
  public void mousePressed(MouseEvent e){ }
  public void mouseReleased(MouseEvent e){
//   System.out.println("RELEASED!");
  }
  public void mouseEntered(MouseEvent e){ }
  public void mouseExited(MouseEvent e){ }
  public void Standardize(double xx[][]) {
   double mean[] = new double[nc];
   double sd[] = new double[nc];
// Compute means and standard deviations.
   for (int j=0; j<nc; j++) {
    double sum=0.0;
    for (int i=0; i<nr ;i++) {
     sum += xx[i][j];
    }
    mean[j] = sum/(double)nr;
   }
   for (int j=0; j<nc; j++) {
    double temp=0.0;
    for (int i=0; i<nr; i++) {
     temp += Math.pow((xx[i][j] - mean[j]),2);
    }
    sd[j] = Math.sqrt(temp/(double)(nr-1));
   }
// Standardize data.
   for (int i=0; i<nr; i++){
    for (int j=0; j<nc; j++) {
     xx[i][j] = (xx[i][j] - mean[j])/sd[j];}}
  }

  public static void main(String argv[]) throws IOException 
  {
//    System.out.print("Standardized or not (Y or N)?");
//    a = (char) System.in.read();
    ViVA f = new ViVA(argv[0]);
    f.resize(700,700);
    f.show();   
  } 


  public class PtCanvas1 extends Canvas implements Runnable, MenuContainer
  {
    double maxx, minx;
    double maxy, miny;
    int end;
    Thread t;
    Image buf;
    Graphics gBuf;
    int tour_len = 0;
    private boolean suspend;
    private boolean Construct_Tree;  
    Dimension d;
    int Plotsz, GraphWth, GraphHgt, xOrigin, yOrigin, xCenter, yCenter;

    public PtCanvas1() 
    {
      t = new Thread(this);
      t.start();
      erase = new boolean[nr];
      suspend = false;
      Construct_Tree = false;
      SD = new MSTgraph("Ordered Edge Weights Graph",nr);
      SD.addMouseMotionListener(SD.mmHandler);
    }

    public void MinimalSpanning_Tree() 
    {      
      mst_count++;
      if (Construct_Tree == false) 
      { SD.EraseBrush(erase,nr);
        SD.EraseBrush(SD.under_brush, nr);
        MSTdata.show(MSTree, 1, 20); }
      else if (Construct_Tree == true) 
      { Construct_Tree = false;
        SD.Peel_toOriginal(); 
        SD.setVisible(false); }  
    }

    public void MenuShow(int idx)
     throws FileNotFoundException {
     SD.DataChoice = idx;
     Construct_Tree = true;
     if (idx==0) {
// Calculate Minimal Spanning Tree
      if (mst_count==1) 
       { Cn = new Cnode();
         SD.distance =  new double[nr+1][nr+1];
         SD.Tree(GT2.raw_data);
         SD.distance=null;
       }     
     } else if (idx==1) {
// Read Minimal Spanning Tree from File

// File "data file name.mst" consists of three columns, starting and ending
// points of edge and the edge distance
// The file should be in ascending order of edge distance.

      if (mst_count==1)
      {  Data1 Dt1 = new Data1();
         try{ Dt1.readData(ViVA.fn.concat(".mst")); }
         catch(IOException e){ }
         if (Dt1.ncols!=3){  
          System.out.println("Error: More than 3 columns in .mst file"); 
          System.exit(1);}
         Cn = new Cnode(Dt1.x,nr-1);
         SD.distance1 =  new double[nr+1];    
         SD.Tree(Dt1.x); 
         Dt1=null;
         SD.distance1=null;
      }
     } //end if (idx==1)
     SD.setVisible(true);
     System.gc();
    } 

    public void Sus_Res() 
    {
      if (suspend == false) 
      { t.suspend();suspend = true; } 
      else if (suspend == true) 
      { t.resume();suspend = false;}
    }

    public void run() 
    { 
      while(true)
      { 
        if (tour_len == 0) 
        { try{GT2.init_gt();} catch(SVDCException e) { }
          for (int i=0; i<nr;i++){ 
            for (int j=0; j<nd; j++) {gp[i][j]=GT2.gt_proj[i][j];}}
          end = nr;
          scalepoints(gp);
          repaint(); 
          try{t.sleep(200);} catch (InterruptedException e){ }
          tour_len++;
	} else if (tour_len > 0)
        { try{ GT2.run_tour(st);} catch(SVDCException e) { }
          for (int i=0; i<nr;i++){
            for (int j=0; j<nd; j++) 
            {gp[i][j]=GT2.gt_proj[i][j];}}
          end = nr;
          scalepoints(gp);
          repaint(); 
          try{t.sleep(200);} catch (InterruptedException e){ }
          tour_len++; }
      }
    }

    public void update(Graphics g)
    {      paint(g);  }

    public void paint(Graphics g) 
    { if (buf != null) {
        draw();
        g.drawImage(buf,0,0,this);} 
      else {
        buf = createImage(900,900);
        gBuf = buf.getGraphics();  
        draw();   
        g.drawImage(buf,0,0,this);}
    }

    void draw() 
    { gBuf.setColor(Color.black);
      gBuf.fillRect(0,0,900,900);
      int j,k=0;
      if (end <= nr )
      { drawPoints(gBuf,end,gp,xCenter,yCenter);
        if (Construct_Tree == true)  {  
          for (int i=0; i<end-1; i++) 
          {
            if (!erase[i]){
             gBuf.setColor(Color.yellow.darker());
            }
            if (erase[i]){
             gBuf.setColor(Color.gray);
            }                      
            drawMinimalSpanningTree(gBuf,gp,SD.sta[i],SD.end[i],
              xCenter,yCenter);
	  }
	}
      } 
      else if (end > nr) {
        gBuf.setColor(Color.black);
        gBuf.fillRect(0,0,500,500);}
    }
 
    public void scalepoints(double p[][]) 
    {
      d = this.getSize();
      GraphWth = d.width * 8/10;
      GraphHgt = d.height * 8/10;
      Plotsz = Math.min(GraphWth, GraphHgt);
      xOrigin = (d.width-GraphWth)/2;
      yOrigin = (d.height-GraphHgt)/2;
      xCenter = xOrigin+GraphWth/2;
      yCenter = yOrigin+GraphHgt/2;
    
      double rangex = 2;
      double rangey = 2;
      for (int i=0; i<nr; i++) {p[i][0] = p[i][0]/rangex*GraphWth;}
      if (nd > 1){
        for (int i=0; i<nr; i++) {p[i][1] = p[i][1]/rangey*GraphHgt;}
      }
    }


    public void drawPoints(Graphics g, int cont, double p[][], 
      int xcent, int ycent)
    { g.setColor(Color.gray);
      if (nd > 1){
        for (int i=0; i<cont; i++)
        { if (aa==1) g.setColor(pcolor[i]);
          g.fillOval((int)p[i][0]+xcent-1, (int)p[i][1]+ycent-1,6,6);}  
      }else{
        for (int i=0; i<cont; i++)
        { if (aa==1) g.setColor(pcolor[i]);
          g.fillOval((int)p[i][0]+xcent-1, 0+ycent-1,6,6);}  
      }
    }

    public void drawMinimalSpanningTree(Graphics g, double p[][],
               int s, int e, int xcent, int ycent) 
    { if (nd > 1)
      { g.drawLine((int)p[s][0]+xcent,(int)p[s][1]+ycent,
              (int)p[e][0]+xcent,(int)p[e][1]+ycent);  
        g.drawString(Integer.toString(s+1),(int)p[s][0]+xcent, (int)p[s][1]+ycent);
        g.drawString(Integer.toString(e+1),(int)p[e][0]+xcent, (int)p[e][1]+ycent);
      }
      else
      { g.drawLine((int)p[s][0]+xcent,0+ycent,(int)p[e][0]+xcent,0+ycent); 
        g.drawString(Integer.toString(s+1),(int)p[s][0]+xcent, 0+ycent);
        g.drawString(Integer.toString(e+1),(int)p[e][0]+xcent, 0+ycent); 
      }
    }

  }

}