//int W_WIDTH = screen.width/2;
//int W_HEIGHT = screen.height/2;
final int W_WIDTH = 896;
final int W_HEIGHT = 480;
int INPUT_LENGTH = 64;
List<Long[]> bitLines = new LinkedList<Long[]> ();
int CELL_SIZE = 7;

int PIXELS_PER_COL = 64;
int LINES_PER_FRAME = 1;
int RULE = 105;
int MAJOR_COLS = 0;
int GRID_HEIGHT = 0;
int GRID_WIDTH = 0;

int DRAW_METHOD = 0; // 0 for bitwise, 1 for words, 2 for bytes
final int DRAW_BITS = 0, DRAW_WORDS = 1, DRAW_BYTES = 2;

int COLOR_ROTATION = 0;
float COLOR_CYCLE_LENGTH = 60; // In seconds

Long[] input;

PFont fnt, smallFnt;
PGraphics pBuf = createGraphics (W_WIDTH,W_HEIGHT,JAVA2D);

void Reset () {
  MAJOR_COLS = W_WIDTH/CELL_SIZE/PIXELS_PER_COL;
  GRID_HEIGHT = W_HEIGHT/CELL_SIZE;
  GRID_WIDTH = PIXELS_PER_COL*MAJOR_COLS;
  COLOR_ROTATION = 0;
  input = new Long[MAJOR_COLS];
  bitLines.clear();
  for (int i=0; i<input.length; i++) input[i] = 0L;
  if ( (float)MAJOR_COLS % 2 == 0)
    input [MAJOR_COLS/2-1] = 1L;
  else
    input[MAJOR_COLS/2] = 1L << 32;
  bitLines.add (input);
  pBuf.beginDraw ();
  pBuf.background (0,0,0);
  pBuf.endDraw ();
}

void setup () {
  //size (W_WIDTH,W_HEIGHT);
  size (896,480);
  frameRate(30);
  noSmooth ();
  noStroke ();
  fnt = loadFont ("Lane-Narrow-48.vlw");
  smallFnt = loadFont ("Lane-Narrow-24.vlw");
  textFont (fnt,48);
  pBuf.beginDraw ();
  pBuf.background (0,0,0);
  pBuf.endDraw ();
  Reset ();
  addMouseWheelListener(new java.awt.event.MouseWheelListener() { 
    public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) { 
      mouseWheel(evt.getWheelRotation());
  }}); 
}

Long[] ComputeLine (Long[] inputStr, int rule) {
  Long[] output = new Long[MAJOR_COLS];
  long tripleMask = 0x07L;
  long remainder = 0L;

  for (int col=MAJOR_COLS-1; col>=0; col--) {
    long inSegment = inputStr[col];
    long outSegment = 0L;
    
    // Special case for first bit of output
    int token = (int) (((inSegment << 1) | remainder) & tripleMask);
    int ruleBit = 1 << token;
    if ((rule & ruleBit) == ruleBit)
      outSegment = outSegment | 1L;
      
    for (int i=0; i<=61; i++) {
      token = (int) ((inSegment >>> i) & tripleMask); // Get three-digit code (eg: 101)
      ruleBit = 1 << token; // Get bitmask to check rule
      if ((rule & ruleBit) == ruleBit) // Rule is draw pixel
        outSegment = outSegment | (1L << (i+1));
    }
    
    // Special case for last bit of output, if not on last column
    if (col > 0) {
      long nextSegment = inputStr[col-1];
      long firstBitMask = (nextSegment << 2) & tripleMask;
      token = (int) (((inSegment >> 62) | firstBitMask) & tripleMask);
      ruleBit = 1 << token;
      if ((rule & ruleBit) == ruleBit)
        outSegment = outSegment | (1L << 63);
    } else {
      token = (int) ((inSegment >> 62) & tripleMask);
      ruleBit = 1 << token;
      if ((rule & ruleBit) == ruleBit)
        outSegment = outSegment | (1L << 63);
    }
    
    remainder = inSegment >>> 63;
    output[col] = outSegment;
  }
  return output;
}

void PrintLine (Long[] inputStr) {
  for (int col=0; col<inputStr.length; col++) {
    print ("[");
    long inSegment = inputStr[col];
    for (int i=0; i<64; i++) {
      long bitMask = 1L << (63-i);
      if ((inSegment & bitMask) == bitMask) print ("1");
      else print ("0");
    }
    print ("]");
  }
  print ("\n");
}

void DrawBitLine (Long[] inputStr, int x, int y) {
  for (int col=MAJOR_COLS-1; col>=0; col--) {
    long inSegment = inputStr[col];
    for (int i=0; i<64; i++) {
      long bitMask = 1L << (63-i);
      if ((inSegment & bitMask) == bitMask) {
        pBuf.fill(0,200,0);
        pBuf.rect (col*CELL_SIZE*64 + x + i*CELL_SIZE + 1,y + 1, CELL_SIZE - 2,CELL_SIZE - 2);
      }
      else pBuf.fill(255,255,255);
    
    }
  }
}

void DrawWordLine (Long[] inputStr, int x, int y) {
  for (int col=MAJOR_COLS-1; col>=0; col--) {
    long inSegment = inputStr[col];
    for (int i=0; i<63; i+=2) {
      long bitMask = 3L;
      long digits = inSegment >> (62-i);
      long word = digits & bitMask;
      switch ((int) word) {
        case 0: continue;
        case 1: pBuf.fill (255,0,0);
                break;
        case 2: pBuf.fill (0,255,0);
                break;
        case 3: pBuf.fill (0,0,255);
                break;
      }
      pBuf.rect (col*CELL_SIZE*32 + x + (i/2)*CELL_SIZE + 1,y + 1, CELL_SIZE - 2,CELL_SIZE - 2);    
    }
  }
}

void DrawByteLine (Long[] inputStr, int x, int y) {
  for (int col=MAJOR_COLS-1; col>=0; col--) {
    long inSegment = inputStr[col];
    for (int i=0; i<61; i+=4) {
      long bitMask = 15L;
      long digits = inSegment >> (62-i);
      long word = digits & bitMask;
      if (word == 0) continue;
      
      float t = (TWO_PI) * (frameCount % (frameRate*COLOR_CYCLE_LENGTH)) / (float)(frameRate*COLOR_CYCLE_LENGTH);
      float n = (word+5) % 16;
      int r = (int) (sin(t)*75 +              180*(((int)word+0)%16)/16);
      int g = (int) (sin(t+(TWO_PI/3))*75 +   180*(((int)word+5)%16)/16);
      int b = (int) (sin(t+(2*TWO_PI/3))*75 + 180*(((int)word+10)%16)/16);
      pBuf.fill (r,g,b);
      pBuf.rect (col*CELL_SIZE*PIXELS_PER_COL + x + (i/4)*CELL_SIZE + 1,y + 1, CELL_SIZE - 2,CELL_SIZE - 2);    
    }
  }
}

void DrawLine (Long[] input, int idx) {
  switch (DRAW_METHOD) {
      case DRAW_BITS: DrawBitLine(input,0, idx*CELL_SIZE);
                      break;
      case DRAW_WORDS: DrawWordLine(input,0,idx*CELL_SIZE);
                       break;
      case DRAW_BYTES: DrawByteLine(input,0, idx*CELL_SIZE);
                       break;
    }
}

void draw () {
  background (0,0,0);
  pBuf.beginDraw ();
  
  if (bitLines.size() == 1) DrawLine (bitLines.get(0), 0);
  if (bitLines.size() + LINES_PER_FRAME > GRID_HEIGHT) {
    int nShift = (bitLines.size () + LINES_PER_FRAME) - GRID_HEIGHT;
    for (int i=0; i<nShift; i++) bitLines.remove (0);
    int pShift = nShift * CELL_SIZE;
    pBuf.copy (0,pShift,W_WIDTH,W_HEIGHT-pShift,0,0,W_WIDTH,W_HEIGHT-pShift);
    pBuf.fill (0,0,0);
    pBuf.rect (0,W_HEIGHT-pShift,W_WIDTH,pShift);
  }
  for (int i=0;i<LINES_PER_FRAME;i++) {
    input = ComputeLine (input, RULE);
    bitLines.add (input);
    
    DrawLine (input, bitLines.size()-1);
  }
  pBuf.endDraw ();
  image (pBuf,0,0);
  
  fill (0,0,0,128);
  rect (5,5,200,55);
  rect (5,W_HEIGHT-60,200,55);
  fill (255,255,255);
  textFont (fnt,48);
  text ("Rule " + Integer.toString(RULE),13,50);
  //textFont (smallFnt,24);
  text ("FPS:  " + Integer.toString((int)frameRate),13,W_HEIGHT-17);
}

Long[] PadBitstring (Long[] bitstring, int padding) {
  int paddingCols = padding / 64;
  int remainder = padding % 64;
  List<Long> paddedBitstring = new LinkedList<Long> ();
  for (int i=0; i<paddingCols; i++) paddedBitstring.add (0L);
  long remainingData = 0L;
  int startIdx = 0;
  if (remainder > 0) {
    long section = bitstring[0] >> remainder;
    remainingData = bitstring[0] << remainder;
    paddedBitstring.add (section);
    startIdx = 1;
  }
  for (int i=startIdx; i<bitstring.length; i++) {
    long section = bitstring[i];
    long newSection = (section >> remainder) | remainingData;
    if (remainder > 0) remainingData = section << remainder;
    paddedBitstring.add (newSection);
  }
  if (remainder > 0) {
    paddedBitstring.add (remainingData);
  }
  for (int i=0; i<paddingCols; i++) paddedBitstring.add (0L);
  Long[] r = new Long[paddedBitstring.size()];
  r = paddedBitstring.toArray (r);
  return r;
}

Long[] StripBitstring (Long[] bitstring, int amount) {
  int stripped = 0;
  int toStrip = amount;
  int bitsToKeep = bitstring.length * 64 - amount * 2;
  int keptSoFar = 0;
  List<Long> strippedBitstring = new LinkedList<Long> ();
  
  int idx = 0;
  for (toStrip=amount; toStrip>=64; toStrip-=64)
    idx += 1;
  for (int i=idx; i<bitstring.length && keptSoFar < bitsToKeep; i++) { 
    long section = bitstring[i];
    if (toStrip == 0) {
      strippedBitstring.add (section);
      keptSoFar += 64;
      if (keptSoFar > bitsToKeep) print ("kept too many bits!");
      continue;
    }
    long newSection = section << toStrip;
    long nextChunk = bitstring[i+1];
    newSection = newSection | (nextChunk >>> toStrip);
    strippedBitstring.add (newSection);
    keptSoFar += 64;
  }
  Long[] r = new Long[strippedBitstring.size()];
  r = strippedBitstring.toArray (r);
  return r;
}

void oldsetup () {
  Long[] bstr = new Long[2];
  Long[] padstr, padstr2, strpstr;
  bstr[0] = 1L;//(1L << 63);
  bstr[1] = 0L;
  padstr = PadBitstring(bstr,32);
  padstr2 = PadBitstring(padstr,96);
  PrintLine (bstr);
  PrintLine (padstr);
  strpstr = StripBitstring (padstr,32);
  
  //PrintLine (padstr2);
  PrintLine (strpstr);
}

void keyPressed () {
  if (keyCode == RIGHT) {
    RULE += 1;
    if (RULE > 255) RULE = 1;
  } else if (keyCode == LEFT) {
    RULE -= 1;
    if (RULE < 1) RULE = 255;
  } else if (keyCode == UP) {
    RULE += 10;
    if (RULE > 255) RULE = RULE - 255;
  } else if (keyCode == DOWN) {
    RULE -= 10;
    if (RULE < 1) RULE = 255 + RULE;
  }
}

void mousePressed () {
  if (mouseButton == LEFT) {
    //oldsetup (); print ("\n");
    Long[] firstLine = bitLines.get(0);
    int oldLength = bitLines.size ();
    DRAW_METHOD += 1;
    if (DRAW_METHOD > 2) DRAW_METHOD = 0;
    Long[] newInput = null;
    switch (DRAW_METHOD) {
      case DRAW_BITS:  PIXELS_PER_COL = 64;
                       newInput = StripBitstring (firstLine, MAJOR_COLS*64*3/4/2);
                       break;
      case DRAW_WORDS: PIXELS_PER_COL = 32;
                       newInput = PadBitstring (firstLine, MAJOR_COLS*64/2);
                       break;
      case DRAW_BYTES: PIXELS_PER_COL = 16;
                       newInput = PadBitstring (firstLine, MAJOR_COLS*64/2);
                       break;
    }
    Reset ();
    bitLines.clear ();
    input = newInput;
    pBuf.beginDraw ();
    bitLines.add (input);
    DrawLine (input, 0);
    for (int i=0;i<oldLength-1;i++) {
      input = ComputeLine (input, RULE);
      bitLines.add (input);
      DrawLine (input, bitLines.size()-1);
    }
    pBuf.endDraw ();
  } else if (mouseButton == RIGHT) {
    Reset ();
  }
}

void mouseWheel (int delta) {
  LINES_PER_FRAME += delta;
  if (LINES_PER_FRAME < 0) LINES_PER_FRAME = 0;
}