//------------------------------------------------------
// VISP --NANO-- infoVis-- October 2005
// piece of software mede for medien.KUNSTLABOR VISP installation in Graz (Austria)
// by Alessandro Capozzo for Machfeld ( aka Sabine Maier & Michael Mastrototaro)
// www.abstract-codex.net
// www.machfeld.net
// data baase and data evalutation by Markus Reisenhofer
// -------------------------------------------------------
// built with processing beta .92 
// review with beta .124 may 2007
// www.processing.org
// nanoXML library was used to parse data
// nanoxml.cyberelf.be
//----------------------------------------------------------
//  applet based on RELATION, an older abstract-codex work
//----------------------------------------------------------


import java.lang.reflect.Array;

 
// parsing init-----------------------------------------
nanoxml.XMLElement messages = new nanoxml.XMLElement();

MessageObj [] messagesIstance;
VispObj [] vispCluster;

Object[] records;
int prp=0;
float milliToHour=1/3600000;
boolean selection=true;
//----------------------------------------------------

// infoVis init --------------------------------------
Structure [] list;
int num=1;
int countList=100;
int medx,medy;
boolean newTarget=true;
int idNewDist;
float newDistAbs,oldDistAbs;
int trans;
//-----------------------------------------------------
int counterJump;
///
PFont font; 


void setup(){
  size(720,480,P3D);
  framerate(25);
  background(255);
  font = loadFont("small.vlw"); 
  textFont(font, 8); 
  counterJump=0;
 // parse
  Reader reader = new InputStreamReader(openStream("messages_attribs_xml.xml")); 
    try{ 
   messages.parseFromReader(reader); 
   records = messages.getChildren().toArray();
   initMessages();
    } 
    catch (Exception e) { e.printStackTrace(); } 
    //----------
   setupNew(); 
     
      

}
void keyReleased(){
   if (key == 'n' || key == 'N') { 
      selection=false;
      setupNew();
    } 
    if (key == 'o' || key == 'O') { 
      selection=true;
      setupNew();
    } 
    
}
void mousePressed() 
{ 
   newTarget=false;
} 
void mouseReleased() 
{ 
   newTarget=true;
   trans=0;
} 
void setupNew (){
      idNewDist=0;
  
  
    int countDown=vispCluster.length-1;
  list=new Structure[countList];
  boolean typeV;
  if(selection){
  for(int index=0;index<countList;index++){
    int xx=int(random(width)+1);
    int yy=int(random(height)+1);
    list[index]=new Structure(index,num,xx,yy,vispCluster[index]);
    list[index].startMe();
  }
  }else {
     for(int index=0;index<countList;index++){
    int xx=int(random(width)+1);
    int yy=int(random(height)+1);
   /* if(vispData[index].genus==1){
       typeV=true;
    }else{
       typeV=false;
    }*/
    list[index]=new Structure(index,num,xx,yy,vispCluster[countDown-index]);
    list[index].startMe();
  }
  }
}

void initMessages(){
  Object[] firstParse=((nanoxml.XMLElement)records[1]).getChildren().toArray();
  int mlimit=firstParse.length;
  messagesIstance=new MessageObj [mlimit];
  String msgAttribute;
   int catAttribute;
   int verAttribute;
   String subAttribute;
   String dateAttribute;
   long minim=0;
   long newMinim=0;
   Integer msgInt;
   Integer verInt ;
  for(int im=0; im<mlimit; im++){
   msgAttribute=((nanoxml.XMLElement)firstParse[im]).getAttribute("msg_id").toString();
   msgInt = Integer.valueOf(((nanoxml.XMLElement)firstParse[im]).getAttribute("cat").toString());
   catAttribute=msgInt.intValue();
   verInt = Integer.valueOf(((nanoxml.XMLElement)firstParse[im]).getAttribute("ver").toString());
   verAttribute=verInt.intValue();;
   subAttribute=((nanoxml.XMLElement)firstParse[im]).getAttribute("sub").toString(); 
   dateAttribute=((nanoxml.XMLElement)firstParse[im]).getAttribute("date").toString();            
   messagesIstance[im]=new MessageObj(msgAttribute,catAttribute,verAttribute,subAttribute,dateAttribute,im); 
   minim=messagesIstance[im].getAbsTime();
   if(im==0){
     newMinim=minim;
     
    }else if (minim<newMinim){
        newMinim=minim;
        } 
    }
   for(int im=0; im<mlimit; im++){
   messagesIstance[im].setTime(newMinim);
   }
   initCluster();
}
void initCluster(){
   int limitM=messagesIstance.length;
   String myType;
   boolean checkEx;
   int visplenght=0;
   MessageObj tempMessage;
   for(int indM=0; indM<limitM; indM++){
        myType=messagesIstance[indM]._id;
        checkEx=false;
        
        if(visplenght==0){
           vispCluster=new VispObj[1];
           tempMessage=messagesIstance[indM];
           vispCluster[0]= new VispObj(tempMessage);
           visplenght=vispCluster.length;
        } else {
           visplenght=vispCluster.length;
           for(int nidInd=0; nidInd<visplenght; nidInd++){
              if(myType.equals(vispCluster[nidInd].typeOf())){
                if(!checkEx){
                 vispCluster[nidInd].addChild (messagesIstance[indM]);
                 checkEx=true;
                 //break;
                 }
              } 
           }
           if(!checkEx) {
                 vispCluster=(VispObj[])arrayExpand(vispCluster);
                 vispCluster[visplenght]=new VispObj(messagesIstance[indM]);
                 
              }
              
        }
      
   }
   for(int gg=0; gg<vispCluster.length; gg++){
   if(vispCluster[gg].childrenFlag){
       vispCluster[gg].printme();
      }
      
   }
   
}
class MessageObj {
String msg;
int cat;
int ver;
long absTime;
int relaTime;
int _serialNum;
String _id;
String sub;
String date;
MessageObj(String ms, int ct, int vr, String sb, String dt,int sn){
      msg=ms;
      cat=ct;
      ver= vr;
      sub=sb;
      date=dt;
      absTime=dateMilliSec ( date );
      _id=getId(msg);
      _serialNum=sn;
     }
  private long dateMilliSec (String income){
     Date myTime;
     long myHours70;
     myTime = new Date(income);
     //hours
     myHours70= ((myTime.getTime()));
     return myHours70;
  }
  private String getId(String income){
    String [] sepList = split (income, ":");
    return sepList[0];
  }
  public void setTime (long minimumTime){
     relaTime=int((absTime-minimumTime)/3600000);
    }
  public long getAbsTime (){
     return absTime;
    }
}
class VispObj{
      MessageObj main;
      MessageObj [] idPrivateCluster;
      boolean childrenFlag;
      String _id;
      int callme;
      VispObj(MessageObj mn){
        main=mn;
        childrenFlag=false;
          callme=0;  
        }
      private void addChild (MessageObj newChild){
         callme++;
         if(childrenFlag){
                       
            idPrivateCluster=(MessageObj[])arrayExpand(idPrivateCluster);
            idPrivateCluster[idPrivateCluster.length-1]=newChild;
            
         }else{
           
           childrenFlag=true;
           idPrivateCluster=new MessageObj[1];
           idPrivateCluster[0]=newChild;
          
         }
         
      }
      String typeOf (){
         return main._id;
      }
      void printme (){
         
         for(int pm=0; pm<idPrivateCluster.length; pm++){
              
         }
      }
}
static Object arrayExpand(Object a) {
    Class cl = a.getClass();
    if (!cl.isArray()) return null;
    int lengtha = Array.getLength(a);
    int newLength = lengtha+1;
    Class componentType = a.getClass().getComponentType();
    Object newArray = Array.newInstance(componentType, newLength);
    System.arraycopy(a, 0, newArray, 0, lengtha);
    return newArray;
    }

/****************************************************************************************************************/

void draw() {
  background(230,230,224);
  
  
  for(int index=0;index<countList;index++){
    list[index].update();
  }
   if(newTarget){
   newDistAbs=0;
   //idNewDist=0;
   
   oldDistAbs=width*height;
  for(int index=0;index<countList;index++){
   newDistAbs=abs(dist(list[index].absX,list[index].absY,mouseX,mouseY));
   
   if(newDistAbs<oldDistAbs){
   
    oldDistAbs=newDistAbs;
    idNewDist=index;
    
   }
   
   }
   
  stroke(255);
  
  fill(255);
  ellipse(list[idNewDist].absX,list[idNewDist].absY,10,10);
  line(list[idNewDist].absX,list[idNewDist].absY,mouseX,mouseY);
  fill(255);
  ellipse(mouseX,mouseY,10,10);
  
  } else {
  
  stroke(255);
  
  fill(255);
  ellipse(list[idNewDist].absX,list[idNewDist].absY,10,10);
  line(list[idNewDist].absX,list[idNewDist].absY,mouseX,mouseY);
  
  fill(255);
  ellipse(mouseX,mouseY,10,10);
   
   rect(mouseX+10,mouseY,260,120);
   //bar Code vis
   fill(160);
   text("ID: "+list[idNewDist].idSt,mouseX+20,mouseY+10);
   text("CATEGORY: "+list[idNewDist].catSt,mouseX+20,mouseY+20);
   text("FIRST INCOME: "+list[idNewDist].dateSt,mouseX+20,mouseY+30);
   if(list[idNewDist].numChild==1){
   text("Detected "+list[idNewDist].numChild +" time",mouseX+20,mouseY+40);
   } else {
   text("Detected "+list[idNewDist].numChild +" times",mouseX+20,mouseY+40);
   text("Last time: "+list[idNewDist].lastIn,mouseX+20,mouseY+50);
   }
  /* String dateSt;
  String subSt;
  String idSt;*/
  int codeB;
 for (int bc=0; bc<list[idNewDist].maxTextIntArray; bc++){
        codeB=list[idNewDist].textIntArray[bc];
        
        stroke(codeB+100);
        line (mouseX+bc+20,mouseY+60,mouseX+bc+20,mouseY+110);
     }
  //*/
   }
  
}

class Structure{
  int id;
  int nBall;
  int xBall,yBall;
  public Ball [] cont;
  VispObj myObj;
  int absX,absY;
  float dimR;
  int nx,ny;
  float ang;
  String dateSt;
  String subSt;
  String idSt;
  String textum;
  String catSt;
  String lastIn;
  int  maxTextIntArray;
  int[] textIntArray;
  int numChild;
  Structure (int me,int n,int stx,int sty, VispObj nID){
    id=me;
    nBall=n;
    xBall=stx;
    yBall=sty;
    myObj=nID;
    // da rivedere
    if(myObj.childrenFlag){
    dimR=myObj.idPrivateCluster.length+2;
    numChild=myObj.idPrivateCluster.length+1;
    lastIn=myObj.idPrivateCluster[numChild-2].date;
    } else{
     dimR=3;
     numChild=1;
    }
    if(myObj.main.cat==1){
       catSt="SPAM";
    } else{
     catSt="VIRUS";
    }
    dateSt=myObj.main.date;
    subSt=myObj.main.sub;
    idSt=myObj.main._id;
    nx=0;
    ny=0;
    ang=TWO_PI/dimR;
    textum=subSt;
    maxTextIntArray=160;
    textIntArray=new int[maxTextIntArray];
    txtTransform ();
  }
  void txtTransform (){
         int txtIndex=textum.length();
         for(int tx=0; tx<maxTextIntArray; tx++){
            if(tx<txtIndex){
               textIntArray[tx]=int(textum.charAt(tx));
            } else{
               textIntArray[tx]=255;
            }
         }
      }
  void startMe(){
    cont=new Ball[nBall];
    for (int index = 0; index < nBall; index++) {
      int rx=int(random(500));
      int ry=int(random(500));
      cont[index]=new Ball(.04*(index+2),ry,rx,15,index,xBall,yBall,id);
    }

  }
  void update(){

    ellipseMode(CENTER);
    int colorSpeed=int(abs(cont[0].velocityX)+abs(cont[0].velocityY));
    if(myObj.main.cat==1){
   for (int res = 0; res <nBall; res++) {
    noStroke();
     fill(210,190-colorSpeed,100+colorSpeed,50-(dimR*.2));
      ellipse(nx,ny,dimR,dimR);
      if(!cont[res].contact){
      
      /*stroke(210,180,130);
      fill(210,180,130);*/
      stroke(255);
      fill(100,100,100,100);
      line(nx,ny,nx,ny-30-dimR);
      text(dateSt, nx+5,ny-24-dimR); 
       } else {
          //stroke(255,255,255,10);
         fill(1+cont[0].velocityX,1+cont[0].velocityY,1,30);
         //line(nx,ny,nx,ny-30-dimR);
         text(idSt, nx-30, ny-10); 
       }
     int  ox=cont[res].bx;
     int oy= cont[res].by;
      cont[res].update();
      nx=cont[res].bx;
      ny= cont[res].by;
      absX=nx;
      absY=ny;
      noStroke();
     
     
      
      }
    } else{
     for (int res = 0; res <nBall; res++) {
    noStroke();
     fill(255,30,10,80);
      ellipse(nx,ny,5,5);
      if(!cont[res].contact){
      
      /*stroke(210,180,130);
      fill(210,180,130);*/
      stroke(255);
      fill(100,100,100,100);
      line(nx,ny,nx,ny-30-dimR);
      text(dateSt, nx+5,ny-24-dimR); 
       } else {
          //stroke(255,255,255,10);
         fill(1+cont[0].velocityX,1+cont[0].velocityY,1,30);
         //line(nx,ny,nx,ny-30-dimR);
         text(idSt, nx-30, ny-10); 
       }
     int  ox=cont[res].bx;
     int oy= cont[res].by;
      cont[res].update();
      nx=cont[res].bx;
      ny= cont[res].by;
      absX=nx;
      absY=ny;
      noStroke();
     
     
      
      }
    
    
    }
    
  }
  class Ball {
    int bx,by;
    int difX,difY;
    int dim;
    int me;
    int radius;
    float objX,objY;
    float beta,dist;
    float xSpeed,ySpeed,ndelay;
    float angx,angy,coef;
    int posx,posy;
    float dirX,dirY;
    int sx,sy;
    int adgX,adgY;
    int parent;
    int flagx,flagy;
    float velocityX;
    float velocityY;
    boolean contact;
    Ball(float d,int initX,int initY,int magnitude, int iid,int _sx,int _sy,int _pid){
      ndelay=d;
      bx=initX;
      by=initY;
      difX=0;
      difY=0;
      xSpeed=0.00;
      ySpeed=0.00;
      dim=magnitude;
      me=iid;
      parent=_pid;
      contact=false;
      if(me==0){
        posx=int(random(height));
        posy=int(random(width));
        xSpeed=_sx;
        ySpeed=_sy;
        dirX=xSpeed;
        dirY=ySpeed;
        coef=TWO_PI/40;

      }
    }
    void update (){
      contact=false;
      if(me!=0){
        distance();
      } else{

        float ax=0;
        float ay=0;
        
        int atrac=0;
        float ndelay=.13;
        for (int r1=0;r1<countList-1;r1++){
          if(r1!=id){
            ax+=list[r1].cont[0].bx;
            ay+=list[r1].cont[0].by;
          }

        }
        ax=ax/(countList-1);
        ax=(width*.5-bx)*0.002;
        ay=ay/(countList-1);
        ay=(height*.5-by)*0.002;
        
        int cx=0;
        int cy=0;
        for (int r2=0;r2<countList;r2++){
          if(r2!=id){
            for(int ND=0;ND<num;ND++){
              float distanza=dist(bx,by,list[r2].cont[ND].bx,list[r2].cont[ND].by);
              if(abs(distanza)<8){
                
                cx=cx-(bx-list[r2].cont[ND].bx);
                cy=cy-(by-list[r2].cont[ND].by);
              } else  if((abs(distanza)<70)&&(abs(distanza)>30)){
              //old id+++++++++++++++++++++++++++++++++++++++
               if(true){
                 if(!contact){
                    contact=true;
                 }
                 // colore connesioni
              stroke(220-distanza+velocityX,200-distanza+velocityY,170-distanza+velocityY,75-distanza);
              line(bx,by,list[r2].cont[ND].bx,list[r2].cont[ND].by);
              noStroke();
              float mDist=dist(bx,by,list[r2].cont[ND].bx,list[r2].cont[ND].by);
              //noFill();
              noFill();
                 }
               }
            }
          }

        }
        float velox=0;
        float veloy=0;
        int distC=0;
        for (int r3=0;r3<countList;r3++){
        float distanza=dist(bx,by,list[r3].cont[0].bx,list[r3].cont[0].by);
        if(abs(distanza)<200){
          if(r3!=id){
            distC++;
            velox=velox+list[r3].cont[0].velocityX;
            veloy=veloy+list[r3].cont[0].velocityY;
          }
          }

        }
        velox=velox/(distC);
        velox=(velox-velocityX)*0.08;
        veloy=veloy/(distC);
        veloy=(veloy-velocityY)*0.08;

        velocityX+=ax+cx+velox;
        velocityY+=ay+cy+veloy;

        int limitV=15;
        if(velocityX>limitV){
          velocityX=limitV;
        }
        if(velocityY>limitV){
          velocityY=limitV;
        }
        if(velocityX<-limitV){
          velocityX=-limitV;
        }
        if(velocityY<-limitV){
          velocityY=-limitV;
        }
        bx=bx+int(velocityX);
        by=by+int(velocityY);
        if(bx<30){
          if(velocityX<0){
            velocityX+=1;
          }
          if(bx<0){
            bx+=30;
          }
        }
        if(by<30){
          if(velocityY<0){
            velocityY+=1;
          }
          if(by<0){
            by+=30;
          }
        }
        if (bx>(width-30)){
          if(velocityX>0){
            velocityX-=1;
          }
          if(bx>width){
            bx-=30;
          }
        }
        if (by>(height-30)){
          if(velocityY>0){
            velocityY-=1;
          }
          if(by>height){
            by-=30;
          }
        }
      }
    }
    void distance(){

      objX=cont[me-1].bx-bx;
      objY=cont[me-1].by-by;
      dist=sqrt(sq(objX)+sq(objY));
      if(abs(dist)!=15){
        objY+=.01;
        objX+=.01;
        double betaD=Math.atan(objY/objX);
        beta=(float) betaD;

        if(cont[me-1].by>=by){
          radius=15;
        }else {
          radius=-15;
        }
        if(beta>0){

          bx=cont[me-1].bx-int((radius)*cos(beta));
          by=cont[me-1].by-int((radius)*sin(beta));

        }else {

          bx=cont[me-1].bx+int((radius)*cos(beta));
          by=cont[me-1].by+int((radius)*sin(beta));

        }

        line(cont[me-1].bx,cont[me-1].by,bx,by);

      }

    }
  }

}