import processing.pdf.*;

boolean mouseOver = false;
boolean showCounts = false;
boolean showLabels = false;

String urlData = "http://selfdisclosed.com/forProcessingData.php?data=myData";
String urlColor = "http://selfdisclosed.com/forProcessing.php?color=MyColor";
String urlDataType = "http://selfdisclosed.com/forProcessingDatatypes.php?datatype=myType";

int datanodeCount;
DataNode[] datanodes = new DataNode[12];
HashMap datanodeTable = new HashMap();

int nodeCount;
Node[] nodes = new Node[100];
HashMap nodeTable = new HashMap();

int edgeCount;
Edge[] edges = new Edge[500];

color [] colors = new color[12];
String [] phpData = new String[12];

static final color defaultColor = #F0C070;
static final color selectColor = #FF3030;
static final color fixedColor = #FF8080;

int margin = 25;
int r;
int index = 0;

PFont font;
Node selection;
DataNode dSelection;

//color[] colors = {d1_color, d2_color, d3_color, d4_color, d5_color, d6_color, d7_color, d8_color, d9_color, d10_color, d11_color, d12_color};
String[] ignore = {"a", "of", "the", "i", "it", "you", "and", "to"}; //common words that we don't want to graph
String[] datatypes = {"biographical", "census", "contact", "genealogical", "geographical", "governmental", "intellectual_property", "monetary_standing", "monetary_transactions", "professional", "taste", "virtual"};
boolean record;

void setup() {
  size(800, 600);
  loadData();
  font = createFont("Arial", 10);
  textFont(font);
  smooth();
  
 // noLoop();
}

void loadData() {
  String[]lines=loadStrings(urlData);
  phpData = loadStrings(urlColor);
  String[]datatypeLines = loadStrings(urlDataType);
  
  String datatypeSingleLine = join(datatypeLines, " ");
  String []datatypes2 = splitTokens(datatypeSingleLine, ",");
  arrayCopy(datatypes2, datatypes);
  
  println(datatypes);
  
  color myColor;
  for(int i=0; i<colors.length; i++)
  {
    myColor = unhex(phpData[i]);
    colors[i] = myColor;
  }

  for(int n=0; n<datatypes.length; n++)
  {
    int x = 0;
    int y = 0;
   
    switch(n) {
     case  0: x= margin; y=margin; break;                                          //1
     case 1: x= margin + ((width - (margin))/3); y = margin; break;              //2
     case 2: x= margin + (((width - (margin))/3)*2); y = margin; break;          //3
     case 3: x= width - margin; y=margin; break;                                  //4
     case 4: x= margin; y = height - (margin + (2 * height/3)); break;             //5
     case 5: x= width - margin; y = height - (margin + (2 * height/3)); break;      //6
    case 6:  x= margin; y = height - (margin + (height/3)); break;          //7
     case 7: x= width - margin; y = height - (2*margin + (height/3)); break;   //8
     case 8: x= margin; y = height - margin; break;                                  //9
     case 9: x= margin + ((width - (2*margin))/3); y = height - margin; break;      //10
     case 10: x= margin + (((width - (2*margin))/3)*2); y = height - margin; break;  //11
     case 11: x= width - margin; y = height - margin; break;                          //12
   }
   
   //addNode(datatypes[n], datatypeColors[n]);
   addDataNode(datatypes[n], colors[n], x, y);
  }
  for(int i=0; i < lines.length; i++)
  {
    String[] entity = splitTokens(lines[i], ","); //create an array of entities

    for(int d=2; d <entity.length; d++) {
      if(d >1 && Integer.parseInt(entity[d]) > 0) {
        addEdge(entity[0], datatypes[d - 2], colors[d-2]);
      }
    }
  }
} 

void addEdge(String fromLabel, String toLabel, color nodeColor) { //adds edges to table for future lookup
  //if(ignoreWord(fromLabel) || ignoreWord(toLabel)) return;
  
  println(fromLabel + " " + toLabel);
  
  Node from = findNode(fromLabel, defaultColor);
  DataNode to = findDataNode(toLabel, nodeColor);
  //Node to = findNode(fromLabel, nodeColor);
  from.increment(); //everytime a node is found in the text add to the count
  to.increment();
  
  
  
  for(int i=0; i<edgeCount; i++) { //see if Edge already exists
    if(edges[i].from == from && edges[i].to == to) {
      edges[i].increment();
      return;
    }
  }
  
  Edge e = new Edge(from, to, nodeColor);
  e.increment(); //keep track of number of same edge
  if(edgeCount == edges.length) { //if the array is full
    edges=(Edge[])expand(edges); //make it bigger
  }
  edges[edgeCount++] = e;
}

Node findNode(String label, color nodeColor) { //uses hashTable to look up node based on its label
  label = label.toLowerCase();
  Node n = (Node) nodeTable.get(label);
  if (n == null) {
    return addNode(label, nodeColor);
  }
  return n;
}

Node addNode(String label, color nodeColor) { //adds node to a table for future look up
  Node n = new Node(label, nodeColor);
  if(nodeCount == nodes.length) { //if the look up table is full
    nodes = (Node[]) expand(nodes); //make it bigger
  }
  nodeTable.put(label, n);
  nodes[nodeCount++] = n;
  println(label + " " + n);
  return n;
  
}

DataNode addDataNode(String label, color nodeColor, int x, int y) { //adds node to a table for future look up
  DataNode n = new DataNode(label, nodeColor, x, y);
  datanodeTable.put(label, n);
  datanodes[datanodeCount++] = n;
  println(label + " " + n);
  return n;
  
}

DataNode findDataNode(String label, color nodeColor) { //uses hashTable to look up node based on its label
  //label = label.toLowerCase();
  DataNode n = (DataNode) datanodeTable.get(label);
  return n;
}

boolean ignoreWord(String what) {
  for(int i=0; i<ignore.length; i++) {
    if(what.equals(ignore[i])) {
      return true;
    }
  }
  return false;
}

void draw() {

 //  if(record) {
 //    beginRecord(PDF, "output.pdf");
 //  }

  background(255);
  textFont(font);
  smooth();

  for(int i=0; i<edgeCount; i++) {
   edges[i].relax();
  }
  for(int i=0; i<nodeCount; i++) {
    nodes[i].relax();
  }
  for(int i=0; i<nodeCount; i++) {
    nodes[i].update();
  }
  
  for(int i=0; i<edgeCount; i++) {
    edges[i].draw();
  }
  for(int i=0; i<nodeCount; i++) {
    nodes[i].draw();
  }

  for(int i=0; i<datanodeCount; i++) {
    datanodes[i].draw();
    
  }
  
  
  mouseOver = false;
  
   for(int i=0; i<datanodeCount; i++)
  {
    if(datanodes[i].contains(datanodes[i].x, datanodes[i].y, 5))
    {
      mouseOver = true;
      break;
    }
  }
  
  if(!mouseOver) {
  for(int i=0; i<nodeCount; i++)
  {
    if(nodes[i].contains(nodes[i].x, nodes[i].y, nodes[i].count*2))
    {
      mouseOver = true;
      break;
    }
  }
  }
  
  if(mouseOver) { cursor(HAND);}
  else {cursor(ARROW);}
  
 // if(record) {
 //   endRecord();
 //   record=false;
 //  }
}
void mousePressed() { 
  float closest = 20; //ignore anything greater than this distance
  for (int i=0; i < nodeCount; i++) {
    Node n = nodes[i];
    float d = dist(mouseX, mouseY, n.x, n.y);
    if(d< closest) {  //find a selection if possible
      selection = n;
      closest = d;
      index = i;
    }
  }

  for(int i=0; i <datanodeCount; i++)
  {
    DataNode dn = datanodes[i];
    float dd = dist(mouseX, mouseY, dn.x, dn.y);
    if(dd< closest) { //if the datanode is closer than the regular node selection, trump it
      dSelection = dn;
      closest = dd;
    }
  }
  if(dSelection != null) { //if there is a datanode selection, than that was the closest node of all -- select it
    if(mouseButton == LEFT)
    { 
      if(dSelection.selected) { dSelection.selected = false;} //toggle the highlighted edges associated with the datanode
      else { dSelection.selected = true;}
      
      for(int i=0; i < edgeCount; i++)
      {
       if(edges[i].to == dSelection) //see which edges connect to the datanode
        {
          if(dSelection.selected) //if the datanode is selected highlight all connecting edges
          {
          edges[i].highlight = true;
          }
          else //if the datanode is not selected un-highlight all connecting edges
          {
            edges[i].highlight = false;
            for(int n=0; n<nodeCount; n++)
            { 
              if(nodes[n].selected && nodes[n] == edges[i].from)
              {
                edges[i].highlight = true;
              }
            }
          }
        }
      }
    }
    else if(mouseButton == RIGHT) {
      if(dSelection.labelOn) {dSelection.labelOn = false;}
      else {dSelection.labelOn = true;}
    }
  }
  else if(selection != null) { // if there is not a datanode selected, see if there is a regular node selected
    if(mouseButton == LEFT) {
      if(selection.selected) {selection.selected = false;}  //toggle whether or not the click is highlighting or unhighlighting
      else{selection.selected = true;}
      
      Node[] tempNodes = new Node[nodes.length];
     arrayCopy(nodes, 0, tempNodes, 0, index);
     int left = nodes.length - index-1;
     arrayCopy(nodes, index+1, tempNodes, index, left);
     tempNodes[nodeCount - 1] = nodes[index];
     arrayCopy(tempNodes, nodes);
      
      
      for(int i=0; i < edgeCount; i++)
      {
       if(edges[i].from == selection && selection.selected) //if the click is highlighting, highlight all of the connecting edges
        { 
          edges[i].highlight = true;
        }
        else if(edges[i].from == selection) //if the click is highlighting, make sure the edges that connect to datanodes that are selected are left highlighted
          {
            edges[i].highlight = false;
            for(int d=0; d<datanodeCount; d++)
            { 
              if(datanodes[d].selected && datanodes[d] == edges[i].to)
              {
                edges[i].highlight = true;
              }
            }
            
          }
        }
      }
    else if(mouseButton == RIGHT) {
      if(selection.labelOn) {selection.labelOn = false;}
      else {selection.labelOn = true;}
    }
  }
}

void mouseDragged() {
  if(dSelection != null)
  {
    cursor(HAND);
    dSelection.x = mouseX;
    dSelection.y = mouseY;
    
    for(int i=0; i < edgeCount; i++)
      {
       if(edges[i].to == dSelection)
        {
            edges[i].highlight = true;
        }
      }
  }
  else if(selection != null) {
    selection.fixed = true;
    cursor(HAND);

    selection.x = mouseX;
    selection.y = mouseY;
    
    for(int i=0; i < edgeCount; i++)
      {
       if(edges[i].from == selection)
        {
            edges[i].highlight = true;
        }
      }
  }
}
void mouseReleased() {
  selection = null;
  dSelection = null;
  cursor(ARROW);

}

void keyPressed() {
  if(keyCode == UP) {
    for(int i=0; i < edgeCount; i++)
      {
            edges[i].highlight = true;
       }
   }

   if(keyCode == DOWN) {
     for(int i=0; i < edgeCount; i++)
      {
            edges[i].highlight = false;
      }
  }
  
  if(keyCode == LEFT) {
    for(int i=0; i<nodeCount; i++)
    {
      nodes[i].fixed = false;
    }
      
  }
  
  if(keyCode == RIGHT) {
   if (showCounts) {showCounts = false;}
   else {showCounts = true;}
   
   if(showCounts) {
   for(int i=0; i<datanodeCount; i++)
   {
     datanodes[i].numAttached = true;
   }
   }
   else {
   for(int i=0; i<datanodeCount; i++)
   {
     datanodes[i].numAttached = false;
   }
   }
   
  }
  
  if(key == 'l') {
    if(showLabels) {showLabels = false;}
    else{showLabels = true;}
    
    for(int i=0; i<datanodeCount; i++)
     {
       datanodes[i].labelOn = showLabels;
     }
    for(int i=0; i<nodeCount; i++)
     {
       nodes[i].labelOn = showLabels;
     }
     
  }
  
//  if(key == 'r') {
//      record = true;
//  }
  
  if(keyCode == RETURN || keyCode == ENTER)
  {
    reset();
  }
}


void reset() {
 //datatypes = new String[12];
  //phpData = new String[12];
 // colors = new color[12];
 datanodes = new DataNode[12];
 edges = new Edge[500];
 nodes =  new Node[100];
 nodeTable = new HashMap();
 datanodeTable = new HashMap();
 mouseOver = false;
 datanodeCount = 0;
 nodeCount = 0;
 edgeCount = 0;
 loadData();
}