import it.aos.midi.processing.*;


import processing.opengl.*;

import damkjer.ocd.*;

import java.util.*;
import java.lang.*;

float resMultiplier = 8;

WUSUM wusum;
long[] miditimestamps;


int bufferSize;
int steps;
float limitDiff;
int numAverages=32;
float myDamp=.1f;
float maxLimit,minLimit;

int toomanytooclose = 5;

float[] starsx;
float[] starsy;
float[] starsz;
float[] starsize;

int numstars = 300;

float t;
float tInc;

int W = 700;
int H = 400;
//int W = screen.width;
//int H = screen.height;

int W2 = 3000;
int H2 = 3000;

IDE theIde;

Camera camera1;

void setup(){
  size(700,400,P3D);
  
  
  wusum = new WUSUM(this, 16);
  miditimestamps = new long[16];
  for(int i = 0; i<16; i++){ miditimestamps[i] = 0; }
  
  
  t = 0;
  tInc = 0.01;
  
  starsx = new float[numstars];
   starsy = new float[numstars];
   starsz = new float[numstars];
   starsize = new float[numstars];
   
   for(int i = 0; i<numstars; i++){
     float xx = random(-W2/2,W2/2);
     float yy = random(-H2/2,H2/2);
     float zz = random(-H2/2,H2/2);
     float sz = random(1,8);
     starsx[i] = xx;
     starsy[i] = yy;
     starsz[i] = zz;
     starsize[i] = sz;
   }
  
  
  
  camera1 = new Camera(this,1500,0,5000,   0,0,0);
  
  theIde = new IDE();
  
}



void draw(){
  background(0);
  lights();
  float res = 0.3;
  if(random(0,1)>0.95){ res = 0.7; }
  theIde.run(res);
  
  t += tInc;
  
  camera1.jump(cos(3*t)*1500,sin(2*t)*1500,sin(3*t)*theIde.theGOM.GoMSize*3);
  camera1.feed();
  
  
  noStroke();
   for(int i = 0; i<numstars; i++){
     translate(starsx[i],starsy[i],starsz[i]);
     fill(255,255,255,255);
     box(starsize[i]);
     translate(-starsx[i],-starsy[i],-starsz[i]);
   }
  
  //camera1.tumble(0.01,  0 );
  
  sphereDetail(20);
  shininess(2.0); 
  
  noFill();
  
  stroke(255*sin(theIde.theGOM.t),255*cos(theIde.theGOM.t),255*sin(3*theIde.theGOM.t),40);
  sphere(theIde.theGOM.GoMSize);

  noStroke();
  
  
  shininess(8.0); 
  
  // drawUniverses
  for(int i = 0; i<theIde.theGOM.universes.size(); i++){
    Universe u = (Universe) theIde.theGOM.universes.elementAt(i);
    translate(u.xpos-theIde.theGOM.GoMSize/2,u.ypos-theIde.theGOM.GoMSize/2,u.zpos-theIde.theGOM.GoMSize/2);
    fill(u.r,u.g,u.b,60);
    sphere(u.universeSize);
    // draw automatas
    for(int j = 0; j<u.automatas.size(); j++){
      Automata a = (Automata) u.automatas.elementAt(j);
      translate(a.xpos-u.universeSize/2,a.ypos-u.universeSize/2,a.zpos-u.universeSize/2);
      fill(a.r,a.g,a.b);
      sphere(30*a.happiness*res*8);
      translate(-a.xpos+u.universeSize/2,-a.ypos+u.universeSize/2,-a.zpos+u.universeSize/2);
    }
    translate(-u.xpos+theIde.theGOM.GoMSize/2,-u.ypos+theIde.theGOM.GoMSize/2,-u.zpos+theIde.theGOM.GoMSize/2);
  }
  
  
}


void stop(){
  super.stop();
}













public class GOM{
  
  public float t;
  public float tInc;
  
  public float GoMSize;
  
  long  theDelay;
  
  public Vector universes;
  
  public int numberOfUniverses;
  
  public boolean isGomAlive = false;
  
  public int name;
  
  public GOM(){
    t = 0;
    tInc = random(0.001,0.007);
    
    name = int(random(0,20));
    
    GoMSize = random(1000,3000);
    
    theDelay = (long)(random(10,100));
    
    numberOfUniverses = int( random(1,5) );
    
    universes = new Vector();
    
    for(int counter = 0; counter<numberOfUniverses; counter++){
      Universe aUniverse = new Universe();
      aUniverse.xpos = random(0,GoMSize);
      aUniverse.ypos = random(0,GoMSize);
      aUniverse.zpos = random(0,GoMSize);
      
      universes.addElement( aUniverse );
    }
    
    isGomAlive = true;
    
  }
  
  public void run(float res){
    
      t += tInc;
      //println("GoM[" + name + "-" + GoMSize + "]->" + t);
      
      for(int counter = 0; counter<universes.size(); counter++){
        ((Universe)universes.elementAt(counter)).live(res) ;
      }
      evolve(res);
      

  }
  
  public void evolve(float res){
    // calcolare evoluzion del GoM
    for(int counter = 0; counter<universes.size(); counter++){
      Universe u = ((Universe)universes.elementAt(counter));
      if(u.cycle>u.maxAge){
        universes.remove(u);
      }
    }
    if(random(0,1)>0.8 && universes.size()<2){
      Universe aUniverse = new Universe();
      aUniverse.xpos = random(0,GoMSize);
      aUniverse.ypos = random(0,GoMSize);
      aUniverse.zpos = random(0,GoMSize);
      
      universes.addElement( aUniverse );
    }
  }
  
  
}


public class IDE {


public float t;
public float tInc;

public GOM theGOM;

long  theDelay;

public boolean isUniverseAlive = false;

public IDE(){
  
  t = 0;
  tInc = random(0.001,0.007);
  
  theDelay = (long)(random(100,300));
  
  theGOM = new GOM();
  
  isUniverseAlive = true;
  
}

  public void run(float res){
    
      t += tInc;
      //println("IDE->" + t);
      
      theGOM.run(res);

  }

}


public class Universe{
  
  public float t;
  public float tInc;
  public int cycle;
  
  public int r;
  public int g;
  public int b;

  public Vector automatas;
  public int numberOfAutomatas;
  
  public int name;

  public float xpos;
  public float ypos;
  public float zpos;
  
  public float maxAge;

  
  public float universeSize;
  
  public Universe(){
    t = 0;
    tInc = random(0.001,0.007);
    cycle = 0;
    
    name = int(random(0,20));
    
    maxAge = random(1000,8000);
    
    r = int(random(0,255));
    g = int(random(0,255));
    b = int(random(0,255));
    
    universeSize = random(300,500);
    
    numberOfAutomatas = int( random(1,9) );
    
    automatas = new Vector();
    
    for(int counter = 0; counter<numberOfAutomatas; counter++){
      Automata anAutomata = new Automata();
      
      anAutomata.xpos = random(0,universeSize);
      anAutomata.ypos = random(0,universeSize);
      anAutomata.zpos = random(0,universeSize);
      
      automatas.addElement( anAutomata );
      
    }
  }
  
  public void live(float res){
    cycle++;
    t +=tInc;
    //println("universe[" + name + "]->" + t);
    //println("cycle=" + cycle);
    
    for(int counter = 0; counter<automatas.size(); counter++){
      Automata a = (Automata)automatas.elementAt(counter);
      a.live();
      float dd = dist(universeSize/2,universeSize/2,universeSize/2,a.xpos,a.ypos,a.zpos);
      if(dd>=universeSize/2){
          a.xpos += (universeSize/2 - (a.xpos))/4;
          a.ypos += (universeSize/2 - (a.ypos))/4;
          a.zpos += (universeSize/2 - (a.zpos))/4;
      }
    }
    evolve(res);
  }

  public void evolve(float res){
    // calcolare evoluzione dell'universo

    for(int counter = 0; counter<automatas.size(); counter++){
      Automata a = (Automata)automatas.elementAt(counter);
      if(a.isDead){
        automatas.remove(a);
      } else {
        int tooClose = 0;
        
        float ddmin = universeSize;
        float vx = 0;
        float vy = 0;
        float vz = 0;
        for(int c2 = 0; c2<automatas.size(); c2++){
          if(c2!=counter){
            Automata a2 = (Automata)automatas.elementAt(c2);
            float treshold = resMultiplier*res*a.happiness*universeSize/30;
            float dd = dist(a.xpos,a.ypos,a.zpos,a2.xpos,a2.ypos,a2.zpos);
            if(dd>=treshold){
              tooClose++;
              if(dd<ddmin){
                ddmin = dd;
                vx = (a2.xpos-a.xpos)/40;
                vy = (a2.ypos-a.ypos)/40;
                vz = (a2.zpos-a.zpos)/40;
              }
            }
          }
        }
        if(tooClose!=0){
          a.xpos += vx;
          a.ypos += vy;
          a.zpos += vz;
          if(tooClose>toomanytooclose){
            a.isDead = true;
          }
        }
        a.xpos += cos(2*a.t)*res*universeSize/20;
        a.ypos += sin(a.t)*res*universeSize/20;
        a.zpos += cos(a.t)*res*universeSize/20;
        //println("h*vol=" + (a.happiness*res) );
        if( (a.happiness*res*resMultiplier)>1){
          a.sing(res);
        } 
      }
   }
   
   if(random(0,1)>0.9 && automatas.size()<=2){
     Automata anAutomata = new Automata();
      
      anAutomata.xpos = random(0,universeSize);
      anAutomata.ypos = random(0,universeSize);
      anAutomata.zpos = random(0,universeSize);
      
      automatas.addElement( anAutomata );
   }
   
  }
  

}


public class Automata{
  
  public float t;
  public float tInc;
  
  public int type;

  public int r;
  public int g;
  public int b;
    
    int midiChannel;
    int pan;
    long waitAfter;
    int instrument;
    int note;
    int velocity;
  
  public int[] name;
  
  public float sensibility;
  public float happiness;
  public float desire;
  
  public float sicknessThreshold;
  public int maxSickCycles;
  public int currentContonuousSickCycles;
  
  public float xpos;
  public float ypos;
  public float zpos;
  
  public float maxAge;
  
  public boolean isDead;

  public Automata(){
    t = 0;
    tInc = random(0.001,0.007);
    
    isDead = false;
    
    maxAge = random(10,80);
    
    type = int( random(0,4) );
    
    
    midiChannel = int(random(0,15));
    pan = int(random(0,128));
    waitAfter = int(random(5,30));
    instrument = int(random(0,128));
    velocity = int(random(50,150));;
    
    name = new int[4];
    for(int i = 0; i<4; i++){
      name[i] = int(random(10,127));
    }
    
    r = int(random(0,255));
    g = int(random(0,255));
    b = int(random(0,255));

    
    sensibility = random(0.01,1);
    happiness = random(0.01,1);
    desire = random(0.01,1);
    
    sicknessThreshold = random(1.5,3);
    
    maxSickCycles = int(random(10,1000));
    currentContonuousSickCycles = 0;
  }
  
  public void live(){
    t +=tInc;
    
    //println("[" + type + "][" + name[0] + "-" + name[1] + "-" + name[2] + "-" + name[3] + "]->" + t + "-->h=" + happiness + ",s=" + sensibility + ",d=" + desire + "[csc=" + currentContonuousSickCycles + "]");
    
    evolve();
  }

  public void evolve(){
    // calcolare evoluzione dell'automata
    if( (sensibility+happiness+desire)<sicknessThreshold){
      currentContonuousSickCycles++;
      if(currentContonuousSickCycles>maxSickCycles){
        isDead = true;
      }
    } else {
      currentContonuousSickCycles = 0;
    }
    if(t>maxAge){
      isDead = true;
    }
  }
  
  public void sing(float res){
    
    int r = velocity;
    long  w = waitAfter;
    
    if(res>0.5){
      w = Math.min(127,w*2);
      r = Math.min(127,r*2);
    } else {
      w = w/2;
      r = r/4;
    }
    
    WUSUM.SoundEvent se = wusum.getPANEvent(midiChannel, pan, miditimestamps[midiChannel], w );
    wusum.addEvent(se,midiChannel);
    miditimestamps[midiChannel]++;
    se = wusum.getINSTRUMENT_CHANGEEvent(midiChannel, instrument, miditimestamps[midiChannel], w );
    wusum.addEvent(se,midiChannel);
    miditimestamps[midiChannel]++;
    for(int i = 0; i<4; i++){
      se = wusum.getNOTE_ONEvent(midiChannel, name[i], r, miditimestamps[midiChannel], w );
      wusum.addEvent(se,midiChannel);
      miditimestamps[midiChannel]++;
      se = wusum.getNOTE_OFFEvent(midiChannel, name[i], r, miditimestamps[midiChannel], w );
      wusum.addEvent(se,midiChannel);
      miditimestamps[midiChannel]++;
    }
  }
  

}