import pitaru.sonia_v2_9.*;

//import com.sun.javax.swing.*;


RGS theRGS;
Frame theFrame;

void setup()
{

  theRGS = new RGS();

  size(theRGS.timeAxisSize,theRGS.freqAxisSize);


  // start sonia, and LiveOutput..
  Sonia.start(this,theRGS.SAMPLE_RATE);
  LiveOutput.start(theRGS.framesPerBuffer, 2*theRGS.framesPerBuffer); // Bigger buffers will increase latency, yet reduce 'pop' sounds.
  LiveOutput.setSleep(5); // Set the LiveOutput Thread sleep time (lower numbers will give more power to the sonia engine, but slows down other CPU tasks)
  LiveOutput.startStream();


  theFrame = new ControlFrame("RGS",theRGS);
  theFrame.show();
  theRGS.clearAll();

}

void draw(){

}

public void stop(){
  Sonia.stop();
  super.stop();
}
/* event monitoring */




// serve up the audio buffer
void liveOutputEvent()
{

  for (int i =0;i<theRGS.framesPerBuffer;i++)
  {
    theRGS.audioSamplePointer++;
    if(theRGS.audioSamplePointer>theRGS.audioSampleSize)
      theRGS.audioSamplePointer=0;
    LiveOutput.data[i]=theRGS.audioSample[theRGS.audioSamplePointer];
  };
  // transferred...
}

void mousePressed()
{
  theRGS. mouseWasPressed=true;
  theRGS.mouseDragged();
  //  println("Pressed!");
}
void mouseReleased()
{
  theRGS.mouseWasPressed=false;
  theRGS.dotOnce=false;
  //  println("released!");
}
void mouseMoved()
{
  theRGS.mouseWasPressed=false;
  theRGS.dotOnce=false;
  //  println("moved!");
}


void mouseDragged()
{
  theRGS.mouseDragged();

}

// up 38 left 37 right 39 down 40

void keyPressed()
{
  int keyCode = keyEvent.getKeyCode();
  //  println("KEY EVENT CODE:"+keyCode );
  if((key == 'T')||(key =='t'))
  {
    theRGS.clearAll();
   // println("cleared");    
  }
  if((key == 'R')||(key =='r'))
  {
    theRGS.regen();
    // println("regenned");    
  }
  // key pad ..
  if( (keyCode >= 97) &&(keyCode<=106))
  {
    theRGS.rgsPen = keyCode-97;
    // println("selected pen "+ rgsPen);
  }
  if(key == 'o')
  {
    // write the thing?
  };

  //up
  if(keyCode == 38)
  {
  }
  // down
  if(keyCode == 40)
  {
  }

  //left
  if(keyCode == 37)
  {
    theRGS.setRampAmount( theRGS.rampAmount--);

  }
  // right
  if(keyCode == 39)
  {
    theRGS.setRampAmount( theRGS.rampAmount++);


  }


}


/* RGS object */





class RGS extends Object
{

  int SAMPLE_RATE = 22050;
  //int framesPerBuffer = 512; // LiveOutput buffer size. try 256 as well for better latency performance.

  int framesPerBuffer = 2048; // LiveOutput buffer size. try 256 as well for better latency performance.

  int freqAxisSize=1024;
  // better be well below nyquist
  float topFreq=5000.0;
  float botFreq=topFreq/128.0;

  float  phase[]=new float[freqAxisSize];
  float  phaseInc[]=new float[freqAxisSize];

  // time space: fiddle with these numbers so it's integral
  int samplesPerX = 128;
  int timeAxisSize=800;

  int audioSampleSize=samplesPerX * timeAxisSize;
  float timeAxisSeconds= (float)audioSampleSize/(float)SAMPLE_RATE;
  float secondsPerX = timeAxisSeconds/timeAxisSize;

  float audioSample[] = new float[audioSampleSize];
  int audioSamplePointer= 0;

  int colorSpread=16;
  color ampColors[]= new color[16];
  /* the rgs colors:
   00 00 00 rgb w,  06 06 06 rgb w,  00 00 09 rgb w,
   02 00 00 rgb w,
   04 00 00 rgb w,
   06 00 00 rgb w,
   07 00 00 rgb w,
   08 00 00 rgb w,
   09 00 00 rgb w,
   10 02 00 rgb w,
   11 04 00 rgb w,
   12 06 00 rgb w,
   13 08 00 rgb w,
   14 10 00 rgb w,
   15 13 00 rgb w,
   09 15 05 rgb w, \ phonemic color
   
   */
  float ampColorLow,ampColorHigh;

  float ampArray[]=new float[freqAxisSize*timeAxisSize];

  int rgsPen;
  float mixAmp=1.0/32.0;
  int blob_x=3;
  int blob_y=3;
  float currentAmp=0.8;
  int rampAmount=20;
  boolean mouseWasPressed;
  boolean dotOnce;
  // interface crapola
  Frame theFrame;

  RGS()
  {
    int c,i;
    // amplitude "axis" = color
    c=0;
    ampColorLow=0.0;
    ampColorHigh=1.0;

    if(false)
    {
      for(i=0;i<colorSpread;i++)
      {
        c=i*(255/colorSpread);
        ampColors[i]=  color(c,c*0.75,c*0.5);

      }
    }

    ampColors[0]= color(0,0,0);
    ampColors[1]= color(102,102,102);
    ampColors[2]= color(0,0,153);
    ampColors[3]= color( 34,0,0);
    ampColors[4]= color( 68,0,0); 
    ampColors[5]= color( 102,0,0); 
    ampColors[6]= color(119,0,0);
    ampColors[7]= color(136,0,0);
    ampColors[8]= color(153,0,0);
    ampColors[9]= color(170,34,0);
    ampColors[10]= color(187,68,0);
    ampColors[11]= color(204,102,0);
    ampColors[12]= color( 221,136,0);
    ampColors[13]= color(238,170,0);
    ampColors[14]= color(255,221,0);
    ampColors[15]= color(153,255,85);


    println("Seconds per X:"+ secondsPerX+" Seconds in toto: "+timeAxisSeconds);
    // precalculate phase increment amounts at each y for each sound sample  
    for(i=0;i<freqAxisSize;i++)
    {
      // run this backwards, since y="0" is the top
      float pct = (float)((freqAxisSize-1)-i)/(float)freqAxisSize;
      phase[i]=0.0 ;  // random(0.0,2*PI);
      // if sr = 44100, 1Hz = (2PI/44100) 2 Hz = 2PI/22100)
      phaseInc[i]=2*PI*(pct*(topFreq-botFreq) + botFreq)/(timeAxisSeconds*SAMPLE_RATE);
     // if((i<5)||(i>freqAxisSize-5))
      //  println("pI["+i+"] = "+phaseInc[i]);
    }

    mousePressed=false;

    clearAll();
  }



  void mouseDragged()
  {
    // determine which "pen" to use
    // println("dragged! ud: "+(mousePressed?"up":"down")+" X:"+mouseX+" y:"+mouseY); if(mousePressed)
    int i,j;
    float ampt,sum;

    switch(rgsPen)
    {

    case 0: // Ramp!
      {
        ampt=currentAmp;
        for(i=0;i<rampAmount;i++)
        {
          addSonicPixel(mouseX+i,mouseY,ampt);
          if(i>0)
            addSonicPixel(mouseX-i,mouseY,ampt);
          ampt-=(currentAmp/rampAmount);
        }
        break;
      }
    case 1: // dotty more often
      {

        addSonicPixel(mouseX,mouseY,currentAmp);

        break;
      }
      
     case 2: // dotty once
      {
        if(! dotOnce)
        {
          for(i=0;i<timeAxisSize;i++)
          {
            addSonicPixel(i,mouseY,currentAmp);
          }

        };
        dotOnce=true;
        break;
      }
      
            case 3: // blob
      {

        for(i=-blob_y;i<blob_y+1;i++)
        {
          for(j=-blob_x;j<blob_x+1;j++)
            addSonicPixel(mouseX+j,mouseY+i,currentAmp);
        }
        break;
      }
    case 4: // wipe
      {
        for(i=-blob_y;i<blob_y+1;i++)
        {
          for(j=-blob_x;j<blob_x+1;j++)
            sonicWipe(mouseX+j,mouseY+i);
        }
        break;
      }
    case 5: // filter
      {
        for(i=-blob_y;i<blob_y;i++)
        {
          for(j=-blob_x;j<blob_x;j++)
          {


            sum = sampleAmpAt(mouseX-1,mouseY)*0.25;
            sum += sampleAmpAt(mouseX+1,mouseY)*0.25;
            sum += sampleAmpAt(mouseX,mouseY)*0.5;
            addSonicPixel(mouseX+j,mouseY+i,sum-sampleAmpAt(mouseX,mouseY));
          }
          break;
        }
      }
          case 6: // Down
      {
        ampt=currentAmp;
        for(i=0;i<rampAmount;i++)
        {
          addSonicPixel(mouseX+i,mouseY,ampt);          
          ampt-=(currentAmp/rampAmount);
        }
        break;
      }

      
      
    default:
      break;
    }; // switch

  }

  void addSonicPixel(int x, int y,float amp)
  {
    // amp actually grains
    float  mixedAmp;
    float EASE=10;

    if(x<0) return;
    if(y<0) return;
    if(x>=timeAxisSize) return;
    if(y>=freqAxisSize) return;
    // clamp amp
    if(amp>=1.0) amp=1.0-(1.0/SAMPLE_RATE);
    if(amp<0.0) amp=0.0;
    // println("DDD amp:"+amp+" colorPtr:"+colorPtr);

    float timeStart = x*secondsPerX;

    int samplePtr = x*samplesPerX;
    float myPhase = phase[y]+timeStart*SAMPLE_RATE*phaseInc[y];
    // if I were using Qsins, this would be more interesting

    float pInc= phaseInc[y];
    int coord = clampCoord(x,y);
    // println("sPix: x:"+x+" y:"+y+" sptr:"+samplePtr+" myPhase:"+myPhase+" phaseInc: "+pInc+" phaseInc*samplesize:"+pInc*samplesPerX);
    set(x,y,ampColorOf(amp));
    // a0=ampArray[clampCoord(x-1,y)]*mixAmp;

    //println("DDD add s pix a0:"+a0+" a1:"+a1);
    for(int s=0;s<samplesPerX;s++)
    {    
      mixedAmp=amp*mixAmp;
      audioSample[samplePtr] +=  (mixedAmp ) * sin(myPhase);
      myPhase+=pInc;
      samplePtr++;
    };
    // I wonder...
    if(false)
    {
      int sx2 = samplesPerX/2;
      samplePtr = x*samplesPerX;
      float phase0 = myPhase = phase[y]+timeStart*SAMPLE_RATE*pInc-pInc;
      float phase1  = myPhase = phase[y]+(timeStart+secondsPerX)*SAMPLE_RATE*pInc+pInc; 
      for(int s = 0 ; s<sx2;s++)
      {
        mixedAmp=amp*mixAmp*(float)(sx2-s)/(float)sx2;

        if(samplePtr-1-s>=0)
        {   
          audioSample[samplePtr-1-s]+=mixedAmp*sin(phase0);
        }
        if(samplePtr+1+s<audioSampleSize)
        {   
          audioSample[samplePtr+1+s]+=mixedAmp*sin(phase1);
        }
        phase0-=pInc;
        phase1+=pInc;

      }
    };

    ampArray[coord]=amp;
  }

  int clampCoord(int x, int y)
  {
    if(x<0)x=0;
    if(y<0)y=0;
    if(x>=timeAxisSize) x=timeAxisSize-1;
    if(y>=freqAxisSize) y=freqAxisSize-1;
    return y*timeAxisSize+x;
  }

  void sonicWipe(int x, int y)
  {
    if(x<0) return;
    if(y<0) return;
    if(x>=timeAxisSize) return;
    if(y>=freqAxisSize) return;

    float timeStart = x*secondsPerX;

    int samplePtr = x*samplesPerX;
    // if I were using Qsins, this would be more interesting

    int coord = y*timeAxisSize+x;
    // println("sPix: x:"+x+" y:"+y+" sptr:"+samplePtr+" myPhase:"+myPhase+" phaseInc: "+pInc+" phaseInc*samplesize:"+pInc*samplesPerX);

    set(x,y,ampColorOf(0.0));
    for(int s=0;s<samplesPerX;s++)
    {
      audioSample[samplePtr] =0.0f;
      samplePtr++;
    };
    ampArray[coord]=0.0f;
  }

  float sampleAmpAt(int x, int y)
  {
    return ampArray[ y*timeAxisSize+x];
  }

  color ampColorOf(float amp)
  {
    int ix;
    // below low level? use 2
    if(amp<ampColorLow)
      return ampColors[2];
    if(amp>ampColorHigh)
      return ampColors[15];
    ix = (int)(3.0+12.0*(amp-ampColorLow)/(ampColorHigh-ampColorLow));
    return ampColors[ix];
  }

  public int setRGSPen(int p)
  {
    return rgsPen=p;
  }


  int setRampAmount(int r)
  {
    if(r<1) r=1;
    if(r>100) r=100;
    return   rampAmount=r;
  }

  float setAmpAmount(float r)
  {

    return   currentAmp=r;
  }

  float setMixAmp(float Mix)
  {
    //println("mix:"+Mix);
    return  mixAmp =(1.0f/ (float) Mix);
  };

  void clearAll()
  {
    int i;

    for(i=0;i<freqAxisSize*timeAxisSize;i++)
    {
      ampArray[i]=0.0;
    }
    for(i=0;i<audioSampleSize;i++)
      audioSample[i]=0.0;
    background(ampColors[1]);
  }

  void regen()
  {
    int i,j;
    float aa;
    background(ampColors[1]);
    for(i=0;i<freqAxisSize;i++)
    {
      for(j=0;j<timeAxisSize;j++)
      {
        if((aa = ampArray[i*timeAxisSize+j])!=0.0f)
        {
          set(j,i,ampColorOf(aa));           
        };     
      }

    }

  }
}

class ControlFrame extends Frame
{

  Choice penMenu;
  Scrollbar rangeSlider,ampSlider,mixAmpSlider;
  RGS theRGS;

  ControlFrame(String title,RGS r)
  {

    super(title);
    super.setSize(300,300);
    setLayout(new GridLayout(5,2));
    
    add( new Label("RGS controls",Label.RIGHT));
    penMenu= new Choice();
    penMenu.addItem("Ramp");
    penMenu.addItem("Dots");
    penMenu.addItem("Line");
    penMenu.addItem("Blob");
    penMenu.addItem("Wipe");
    penMenu.addItem("Filter");
    penMenu.addItem("Down");
    // etc
    add(penMenu);
    //
    add( new Label("Range",Label.RIGHT));
    rangeSlider= new Scrollbar(Scrollbar.HORIZONTAL,1,0,1,100);
    add(rangeSlider);
    //
    add( new Label("Amp",Label.RIGHT));
    ampSlider= new Scrollbar(Scrollbar.HORIZONTAL,1,0,1,100);
    add(ampSlider);
    //
    add( new Label("Mix Amp",Label.RIGHT));
    mixAmpSlider= new Scrollbar(Scrollbar.HORIZONTAL,1,0,1,32);
    add(mixAmpSlider);
   //
    add( new Button("Clear (T)"));
    
    theRGS=r;
    
  }
  
  public void setThatRGS(RGS that)
  {
    theRGS=that;
  }



  public boolean handleEvent(Event e)
  {
    // println("Event targ??? :" +e.target );

    if(e.target instanceof Scrollbar)
    {
      Scrollbar s = (Scrollbar) e.target;
      if(e.target == (Object) rangeSlider)
        theRGS.setRampAmount(s.getValue());
      if(e.target == (Object) ampSlider)
        theRGS.setAmpAmount(s.getValue()/100.0f);
      if(e.target == (Object) mixAmpSlider)
      {
        theRGS.setMixAmp(s.getValue());
        theRGS.regen();
      };
      //   println("range Scrollbar:"+s.getValue()+" R:"+theRGS.rampAmount+" a:"+theRGS.currentAmp);
      return true;
    };

    if(e.target instanceof Choice )
    {
      Choice c = (Choice) e.target;
     // println("choice made:"+c.getSelectedItem());
      theRGS.setRGSPen(c.getSelectedIndex());
      return true;
    }
    
  if(e.target instanceof Button )
    {
      Button b = (Button) e.target;
      if(b.getLabel()=="Clear (T)")
      {
      theRGS.clearAll();
      }
     

      return true;
    }
    // something else can handle it

    return false;

  }




}