// code.specific(alpha) by Alessandro Capozzo (Dicember 2005 - March 2006) www.abstract-codex.net;
import java.lang.reflect.Array;

String lines[];

ModularUnit [] cluster = new ModularUnit [0];

PFont font; 
String totString="";

int [] drawArray= new int[0];
String testV="v"+"o"+"i"+"d";
String testC="c"+"l"+"a"+"s"+"s";
String testF="i"+"f";
String testFo="f"+"o"+"r";
String testW="e"+"l"+"s"+"e";
String totCode="";
float ip=PI*.002;
float ip2=0;
float ipR=0;
char testBraOpen=123;
char testBraClose=125;
char testSemi=59;
char parOpen=40;
char parClose=41;
boolean rotCont=false;
boolean rotContFunc=false;
boolean contFirstRec=false;
boolean contShift=false;
boolean pressedR=true;
boolean pressedL=true;
boolean pressedU=true;
boolean pressedD=true;
boolean contScript=false;
float dif,delayR,rSpeed;
float difShX, difShZ;
float delayS=.3;
float xDir=0;
float zDir=0;
void setup(){
    size(640,480,P3D);
    framerate(25);
    noStroke();
    background (234,234,220);
    lines=loadStrings("codespecific_alpha.pde");
    font = loadFont("ISO.vlw"); 
    for (int i=0; i < lines.length; i++) { 
        sumCode(lines[i]) ;
      } 
     analize(totCode,0,"0");
     int clusterCell=cluster.length;
     for (int j=0; j<clusterCell;j++) {
          cluster[j].where_are_myChildren();
          }
       setVis();
}
void draw(){
  background (232,232,226);
  int clusterCell=drawArray.length;
   noFill();
   if (rotCont||rotContFunc){
      rotContFunc=true;
      hackIt();
     }
     if (contShift){
         initPosition();
       }
   
   translate(320,240,-800+zDir);
   pushMatrix();
   ip2+=ip;
   rotateX(PI*ip2);
   rotateZ(PI*ip2);   
   pushMatrix();
   translate(-1300+xDir,0);
    pushMatrix();
  for (int j=0; j<clusterCell;j++) {
        
          cluster[drawArray[j]].drawMe(); 
       
    }
      popMatrix();
     popMatrix();
    popMatrix();
    
}
void hackIt(){
   
   if(rotCont){
     ipR+=ip;
     delayR=.01;
     rSpeed=0;
     } else {
       dif=0 - ipR;
       rSpeed+=dif*delayR;
       rSpeed*=.9;
       ipR+=rSpeed;
       if(Math.abs(dif)<.000001){
          ipR=0;
          rotContFunc=false;
         }
     }
}
void initPosition(){
       difShX=0 - xDir;
       difShZ=0 - zDir;
       xDir+=difShX*delayS;
       zDir+=difShZ*delayS;
       if(Math.abs(difShZ)<0.5 && Math.abs(difShX)<0.5){
          xDir=0;
          zDir=0;
          contShift=false;
         }
     
}
void setVis(){
     int modShort=30;
     int modLong=110;
     int modint=10;
     int absx=0;
     int absy=0;
     int clusterCell=cluster.length;
     boolean contFirstRec=false;
     boolean lastType=false;
     for (int j=0; j<clusterCell;j++) {
        if(cluster[j].myDNAsequence.length==2){
           drawArray=(int [])arrayExpand(drawArray);
           drawArray[drawArray.length-1]=j;
           
            if(cluster[j].selectType){
              if (lastType) {
                    lastType=false;
                    absx+=modShort+modint;
                }
               cluster[j].setMyViz(absx,0,0,'x');
               setVisY(absx,0,0,j,contFirstRec);
               contFirstRec=!contFirstRec;
               absx+=modLong+modint;
               absy=0;
             } else{
               lastType=true;
               cluster[j].setMyViz(absx,absy,0,'x');
                if(absy>=modLong-(modShort+modint)){
                    absx+=modShort+modint;
                    absy=0;
                  } else {
                    absy+=modShort+modint;
                  }
             }
           }
         
       }
       
}
void setVisX(int x,int y,int z,int id, boolean dir){
     int modShort=30;
     int modLong=110;
     int modint=10;
     int rifX=x+modLong+modint;
     int rifZ=z;
     int rifY=y;
     int rifId=id;
     int absx=rifX;
     int absy=rifY;
     int rifChild;
     int clusterCell=cluster[rifId].myChildren.length;
     boolean lastType=false;
     boolean contFirstRec=dir;
     
     for (int j=0; j<clusterCell;j++) {
           rifChild=cluster[rifId].myChildren[j];
           drawArray=(int [])arrayExpand(drawArray);
           drawArray[drawArray.length-1]=rifChild;
                   
            if(cluster[rifChild].selectType){
              if (lastType) {
                    lastType=false;
                    absx+=modShort+modint;
                }
                
               cluster[rifChild].setMyViz(absx,rifY,rifZ,'x');
               setVisZ(absx,absy,rifZ,rifChild,contFirstRec);
               contFirstRec=!contFirstRec;
               absx+=modLong+modint;
               absy=rifY;
             } else{
               lastType=true;
               cluster[rifChild].setMyViz(absx,absy,rifZ,'x');
                if(absy>=modLong-(modShort+modint)){
                    absx+=modShort+modint;
                    absy=rifY;
                  } else {
                    absy+=modShort+modint;
                  }
             }
           
         
       }
}

void setVisY(int x,int y,int z,int id, boolean dir){
    int modShort=30;
     int modLong=110;
     int modint=10;
     int rifX=x;
     int rifZ=z;
     int rifId=id;
     int absx=rifX;
     int absz=z;
     int rifChild;
     int clusterCell=cluster[rifId].myChildren.length;
     boolean lastType=false;
     if(dir){  
     int rifY=y+modLong+modint;
     int absy=rifY;
     for (int j=0; j<clusterCell;j++) {
         rifChild=cluster[rifId].myChildren[j];
         drawArray=(int [])arrayExpand(drawArray);
         drawArray[drawArray.length-1]=rifChild;
           if(cluster[rifChild].selectType){
               if(lastType){
                    lastType=false;
                    absy+=modShort+modint;
                 }
               cluster[rifChild].setMyViz(rifX,absy,rifZ,'y');
              setVisZ(rifX,absy,rifZ,rifChild,dir);
               absy+=modLong+modint;
               absx=rifX;
             } else{
               lastType=true;
               cluster[rifChild].setMyViz(absx,absy,rifZ,'y');
                if(absx>=rifX+modLong-(modShort+modint)){
                    absy+=modShort+modint;
                    absx=rifX;
                  } else {
                    absx+=modShort+modint;
                  }
             }
          
       }
       } else {
         int rifY=y-(modShort+modint);
         int absy=rifY;
         for (int j=0; j<clusterCell;j++) {
         rifChild=cluster[rifId].myChildren[j];
         drawArray=(int [])arrayExpand(drawArray);
         drawArray[drawArray.length-1]=rifChild;
          if(cluster[rifChild].selectType){
               if(j==0){
                 absy-=modShort*3;
                }
               if(lastType){
                    lastType=false;
                    absy-=(modShort+modint)*3;
                 }
               setVisZ(rifX,absy,absz,rifChild,dir);
               cluster[rifChild].setMyViz(rifX,absy,rifZ,'y');
               absy-=(modLong+modint);
               absx=rifX;
               
               
               
             } else{
               lastType=true;
               cluster[rifChild].setMyViz(absx,absy,rifZ,'y');
                if(absx>=rifX+modLong-(modShort+modint)){
                    absy-=(modShort+modint);
                    absx=rifX;
                  } else {
                    absx+=modShort+modint;
                  }
                }
          
           }
         }
}
void setVisZ(int x,int y,int z,int id, boolean dir){
     int rifX=x;
     int rifY=y;
     int rifZ=z;
     int rifId=id;
     int modShort=30;
     int modLong=110;
     int modul=0;
     int modint=10;
     if (rifZ<0){
         modul=modShort+modint;
       } else {
         modul-=modShort+modint;
         }
    
     int absx=rifX;
     int absy=rifY;
     int absz=rifZ;
     int rifChild;
     int clusterCell=cluster[rifId].myChildren.length;
     boolean lastType=false;
     contFirstRec=dir;
     for (int j=0; j<clusterCell;j++) {
         rifChild=cluster[rifId].myChildren[j];
         drawArray=(int [])arrayExpand(drawArray);
         drawArray[drawArray.length-1]=rifChild;
           if(cluster[rifChild].selectType){
               if(lastType){
                    lastType=false;
                    absy=rifY;
                 }
              setVisX(rifX,rifY,absz,rifChild,contFirstRec);
               absz-=modul;
               contFirstRec=!contFirstRec;
               cluster[rifChild].setMyViz(rifX,absy,absz,'z');
               absx=rifX;
               
             } else{
               if (!lastType){
                   absz+=modul;
                 }
               lastType=true;
               cluster[rifChild].setMyViz(rifX,absy,absz,'z');
                if(absx>=rifX+modLong-(modShort+modint)){
                    absy+=modShort+modint;
                    absx=rifX;
                    
                  } else {
                    absx+=modShort+modint;
                    absz-=modShort+modint;
                  }
             }
          
       }
}
void analize(String codeLine,int lev, String id){
      String idSeq=id;
      int level=lev;
      int startLine=0;
      int startBrace=0;
      int preBrace=0;
      int braceLevel=0;
      int parLevel=0;
      int child=0;
      int clusterCell;
      char pointChar;
      boolean control=true;
      boolean controlPar=true;
      String slice;
      int codeIndex=codeLine.length();
      for(int codeCount=0; codeCount<codeIndex;  codeCount++){
          pointChar=codeLine.charAt(codeCount); 
          if(pointChar==parOpen){
               parLevel++;
               controlPar=false;
            
            }
         if (controlPar){
          if (pointChar==testSemi){
             if (control){
               slice=codeLine.substring(startLine,codeCount+1);
               startLine=codeCount+1;
               
               clusterCell=cluster.length;
               cluster=(ModularUnit[])arrayExpand(cluster);
               String les=idSeq+"."+str(child);
               child++;
               cluster [clusterCell] = new ModularUnit(les, slice, "statement", level, clusterCell);
               }
            } else if (pointChar==testBraOpen) {
                      if(braceLevel==0){
                          preBrace=startLine;
                          startLine=codeCount+1;
                          control=false;
                       }
                       braceLevel++;
            } else if (pointChar==testBraClose){
                        braceLevel--;
                      if (braceLevel==0){
                        clusterCell=cluster.length;
                        slice=codeLine.substring(preBrace,startLine-1);
                        cluster=(ModularUnit[])arrayExpand(cluster);
                        String les=idSeq+"."+str(child);
                        child++;
                        cluster [clusterCell] = new ModularUnit(les, slice, "structure", level, clusterCell );
                        analize(codeLine.substring(startLine,codeCount),level+1,les);
                        startLine=codeCount+1;
                        
                }
            }
          } else {
            if(pointChar==parClose){
               parLevel--;
               if (parLevel==0){
               controlPar=true;
               }
            
            }
         }
       }
   
}
void sumCode(String ll){
    totCode+=ll;
}
class ModularUnit  {
      String myDNA;
      String content;
      String typology;
      String myProfile="";
      boolean selectType;
      int myIdentity;
      int []  myChildren;
      int myChildrenNum;
      int [] myDNAsequence;
      int myDNAlength;
      int loc;
      int clusterIndex;
      int _x,_y,_z;
      color bc=color(250,250,250,80);
      int shortMod=30;
      int longMod=110;
      int xshort,yshort,xlong,ylong;
      ModularUnit (String dna, String mycontent, String mytype, int  location, int id){
             myDNA=dna;
             content=mycontent;
             typology=mytype;
             loc=location;
             myIdentity=id;
             myChildrenNum=0;
             myChildren=new int[0];
             init();  
        }
        void init(){
             who_I_am ();
             get_My_Dna ();
          }
        void get_My_Dna (){
            String [] sepList  = split (myDNA, ".");
            myDNAlength=sepList.length;
            myDNAsequence= new int[myDNAlength];
            for( int element=0; element<myDNAlength; element++){
                myDNAsequence[element]=int(sepList[element]);
              }
          }
        void who_I_am () { 
            if(typology.equals("structure")){
                selectType=true;
                for ( int tl=0; tl<structureType.length; tl++){
                      if (content.indexOf(structureType[tl])!=-1){
                           myProfile=structureType[tl];
                           if(myProfile.equals(testV)){
                                bc=color(190,195,210,110);
                             } else if(myProfile.equals(testC)){
                               bc=color(180,200,120,110);
                               } else if (myProfile.equals(testF)) {
                                  bc=color(160,120,150,60);
                                } else if (myProfile.equals(testW)){
                                  bc=color(200,120,120,60);
                                } else if (myProfile.equals(testFo)) {
                                  bc=color(180,180,160,60);
                                }
                           break;
                        }
                  }
             } else {
               selectType=false;
               myProfile=typology;
               bc=color(190,190,190,60);
             }
         } 
         void where_are_myChildren (){
            clusterIndex=cluster.length;
            for ( int somebody=0; somebody<clusterIndex; somebody++){
                 if(somebody!=myIdentity){
                   if(cluster[somebody].are_we_closer(myDNAsequence)){
                       myChildren=(int [])arrayExpand(myChildren);
                       myChildren[myChildrenNum]=somebody;
                       myChildrenNum++;
                    }
                 } 
             }
            
              
          }
          boolean are_we_closer (int [] rna){
                int rnaLength=rna.length;
                if ((rnaLength>=myDNAlength)||(myDNAlength-rnaLength>1)){
                       return false;
                  } else {
                        for (int rc=0; rc<rnaLength; rc++) {
                             if (rna[rc]!=myDNAsequence[rc]) {
                                 return false;
                                 }
                          }
                          return true;
                  }
            }
        void setMyViz (int x, int y, int z, char dir) {
            _x=x;
            _y=y+100;
            _z=z;
            xshort=_x+shortMod;
            yshort=_y+shortMod;
            xlong=_x+longMod;
            ylong=_y+longMod;
         }
        void drawMe() {
             fill(bc);
             
             
            if(selectType){
                         
                beginShape(); 
                    vertex(_x, _y,_z); 
                    vertex(xlong, _y,_z); 
                    vertex(xlong,ylong,_z); 
                    vertex(_x,ylong,_z);  
                endShape(); 
               fill(250,250,250);
               textFont(font,32); 
               text(myProfile, _x, _y+32,_z); 
                
              } else {
                             
               beginShape(); 
                    vertex(_x, _y,_z); 
                    vertex(xshort, _y,_z); 
                    vertex(xshort,yshort,_z); 
                    vertex(_x ,yshort,_z);  
                endShape(); 
               if(rotContFunc){         
                rotateY(PI*(ipR*.01));
               }
               if(contScript){
                pushMatrix();
                    translate(_x, _y,_z); 
                  pushMatrix();
                    rotateY(-HALF_PI);
                    fill(250,250,250);
                    textFont(font,48); 
                    text(content, 0, 0,0); 
                    popMatrix();
                  popMatrix();
                  }
                
              }
         }
        
}
void keyPressed() 
{ 
 if(key==CODED){
      if(keyCode==UP){
         pressedU=false;
         contShift=false;
         zDir+=4;
     } 
       if(keyCode==DOWN){
          pressedD=false;
          contShift=false;
          zDir-=4;
      
        } 
       if(keyCode==RIGHT){
          pressedR=false;
          contShift=false;
          xDir+=4;
       } 
      if (keyCode==LEFT){
         pressedL=false;
         contShift=false;
          xDir-=4;
       }
      
      
     }
     if (key=='h'||key=='H'){
        rotCont=true;
        }
        if (key=='s'||key=='S'){
        contScript=true;
        }
} 
void keyReleased(){
    if(key==CODED){
      
       if(keyCode==UP){
         pressedU=true;
         
     } 
       if(keyCode==DOWN){
          pressedD=true;
          
      
        } 
       if(keyCode==RIGHT){
          pressedR=true;
          
       } 
      if (keyCode==LEFT){
         pressedL=true;
         
       }
       if((pressedU&&pressedD&&pressedL&&pressedR)){
         contShift=true;
       }
     }
      if (key=='s'||key=='S'){
        contScript=false;
        }
     if (key=='h'||key=='H'){
        
        rotCont=false;
       }
      
  
}
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;
    }
String [] structureType = { testV, testC, testF, testW, testFo } ;