class Output {
  ArrayList outputTxt = new ArrayList();
  int textHeight = 17;
  int ymargin = 15;
  int xmargin = 15;
  PFont font;
  boolean maximise = false;
  String filename = null;
  int lastLineLogged = -1;
  boolean outputtoconsole = false;

  public Output() {
    super();
    font = loadFont("EurostileBold-48.vlw");

  }

  public String fromEnd(int i) {
    int index = outputTxt.size() - i - 1;
    if (index < 0) return "";
    if (index >= outputTxt.size()) return "";
    return (String) outputTxt.get(index);
  }

  public void println(String s) {
    outputTxt.add(s);
    if (outputtoconsole) System.out.println(s);  
  } 

  void logFile() {
    if (filename == null) {
      long timeSinceV15Epoch =  (new java.util.Date()).getTime() ;
      timeSinceV15Epoch -= new Long("1158718199473").longValue(); //Processing seems to choke on longs...
      filename = "Stadium-Log-" + timeSinceV15Epoch + ".csv";
    }
    try {
      java.io.PrintWriter file = new java.io.PrintWriter(new java.io.FileWriter(new java.io.File(filename), true));
      if (lastLineLogged<outputTxt.size() && outputTxt.size()>0) {
        for (int i=lastLineLogged+1; i<outputTxt.size(); i++) {
          file.println(outputTxt.get(i)); 
        }    
        lastLineLogged = outputTxt.size()-1;
        file.close();
      }    
    } 
    catch (Exception e) {
      //Silently ignore logging errors...
      //e.printStackTrace();
    }

  }

  float getTopOfPanel() { 
    return (maximise)? height-ymargin-textHeight*(getMaxRows()+1): height-ymargin-textHeight*(showinforows+1); 
  }
  float getMaxRows() { 
    return (height/textHeight)-2; 
  }
  void toggleMaxRows() { 
    maximise = !maximise; 
  }

  void showInfo() {
    float numrows = (maximise)?getMaxRows():showinforows;
    nav.camera2.feed();
    noStroke();
    textFont(font, 16);
    fill(50,0,0);
    rect(-width/2,height/2-ymargin*2-textHeight*(numrows),width,textHeight*(1));  
    fill(200,200,0);
    text("For help press '?'",width/2-textWidth("For help press '?'")-xmargin, height/2-ymargin-textHeight*(numrows));

    String stime = getElapsedTime(graph.steps) ; 
    text(stime,-width/2+xmargin, height/2-ymargin-textHeight*(numrows));
    text("(Model Step: "+graph.steps+")"+(confusion?"    Confusion":"    Guidance to Near Exits"),xmargin-width/2+textWidth("Elapsed Time: 00:00:00          "),height/2-ymargin-textHeight*(numrows));
    fill(100,0,0,50);
    rect(-width/2,height/2-ymargin*2-textHeight*(numrows-1),width,textHeight*numrows + ymargin*2);
    fill(200,200,20);
    for (int i=0;i<numrows;i++) {
      text(fromEnd(i),-width/2+xmargin,height/2-ymargin-textHeight*i);

    }
    nav.camera1.feed();
  }

  String getElapsedTime(long time) {
    int secs = (int)time;
    int hours = secs / (60 * 60);
    secs = secs - hours*60*60;
    int mins = secs / 60;
    secs = secs - mins * 60;
    String stime = "Elapsed Time:  ";
    if (hours<10) stime += "0"+hours; 
    else stime += "" + hours;
    if (mins<10) stime += ":0"+mins; 
    else stime += ":" + mins;
    if (secs<10) stime += ":0"+secs; 
    else stime += ":" + secs + " ";

    return stime;
  }
}

class InfoPanel {
  ArrayList lines;
  color backgroundColor = color(0,0,100);
  color textColor = color(255,255,255);
  int textHeight = 17;
  int ymargin = 15;
  int xmargin = 15;
  float x,y,panelwidth,panelheight;

  PFont font;

  public InfoPanel() {
    super();
    font = loadFont("EurostileBold-48.vlw");

    String [] input = loadStrings("ReadMeStadium.txt");
    lines = new ArrayList();
    lines.add(version);
    for (int i=0; i<input.length; i++) lines.add(input[i]);
  }

  void calcGeometry() {

    x = -width/2+width/8;
    y = -height/2+height/8;
    panelwidth = width/4;
    panelheight = height/4;

    if (lines != null) {
      int nheight = (lines.size()+2)*textHeight;
      panelheight = (nheight>height) ? height : (panelheight>nheight) ? panelheight: nheight;
      float nwidth = 0;
      float twidth;
      for (int i=0; i<lines.size(); i++) {
        twidth = textWidth((String)lines.get(i)) + ymargin*2;
        nwidth = max(nwidth,twidth);    
      }      
      panelwidth = (nwidth>width) ? width : (panelwidth>nwidth) ? panelwidth : nwidth;
      x = (width - panelwidth)/2 - width/2;
      y = (height - panelheight) / 2 - height/2;
    }
  }


  void showInfo() {
    nav.camera2.feed();
    textFont(font,textHeight);
    calcGeometry();

    fill(backgroundColor);
    stroke(textColor);
    rect(x,y,panelwidth,panelheight);
    fill(textColor);
    for (int i =0; i<lines.size(); i++) {
      text((String)lines.get(i),x+xmargin,y+ymargin*2+textHeight*i);      
    }
    nav.camera1.feed();
  }
}

class LineGraphs {
  ArrayList graphs = new ArrayList();
  float gx,gy,gw,gh;
  float maxV,minV;
  float margin = 10;
  float labelLineWidth = 10;
  boolean maxSet = false;
  boolean minSet = false;
  boolean shownumbers = true;
  color backColor;
  int textHeight = 14;
  float offX = -width/2, offY = -height/2;
  PFont font;

  public LineGraphs(float _x, float _y, float _w, float _h, PFont _font) {
    gx = _x; 
    gy = _y; 
    gw = _w; 
    gh = _h;
    backColor = color(100,100);
    font = _font;
  }

  float getMinFromData() {
    float best=0;
    float cur;
    for (int i=0; i<graphs.size(); i++) {
      cur = getGraph(i).getMinFromData();
      if (i==0 || best > cur) best = cur; 
    }
    return best;
  }

  float getMaxFromData() {
    float best=0;
    float cur;
    for (int i=0; i<graphs.size(); i++) {
      cur = getGraph(i).getMaxFromData();
      if (i==0 || best < cur) best = cur; 
    }
    return best;
  }

  void setMaxToMax() {
    setMax(getMaxFromData());
  }
  void setMinToMin() {
    setMin(getMinFromData());
  }

  void setMax(float max) {
    maxV = max;
    maxSet = true;
    LineGraph lg;
    for (int i=0; i<graphs.size(); i++) {
      lg = (LineGraph) graphs.get(i);
      lg.setMax(getMax());  
    }
  }

  void setMin(float min) {
    minV = min;
    minSet = true;
    LineGraph lg;
    for (int i=0; i<graphs.size(); i++) {
      lg = (LineGraph) graphs.get(i);
      lg.setMin(getMin());  
    }
  }

  float getMax() {
    return maxV;
  }

  float getMin() {
    return minV;
  }


  void makeNewGraph(String label, color c) {
    textFont(font,textHeight);
    float textw = textWidth("0000000--00000000")+labelLineWidth;
    LineGraph lg = new LineGraph(gx+margin,gy+margin,gw-margin*2-textw,gh-margin*2,c,label);
    graphs.add(lg);
    if (maxSet) lg.setMax(getMax());
    if (minSet) lg.setMin(getMin());
  }

  LineGraph getGraph(int i) {
    return (LineGraph) graphs.get(i);
  }

  void addDataPoint(int lineNum, float data) {
    getGraph(lineNum).addDataPoint(data);  
  }

  void draw() {
    nav.camera2.feed();
    float drawn[] = new float[graphs.size()];
    float offset[] = new float[graphs.size()];

    fill(backColor);
    rect(gx+offX,gy+offY,gw,gh);
    textFont(font,textHeight);

    LineGraph lg;
    for (int i=0; i<graphs.size(); i++) {
      lg = getGraph(i);
      if (i==0) lg.drawGrid(color(100,100,0), color(0));
      lg.draw();
    }
    
    calcDrawLabels(drawn, offset);
    drawLabels(drawn, offset);
    nav.camera1.feed();
  }

  void calcDrawLabels(float drawn[], float offset[]) {
    for (int i=0; i<graphs.size(); i++) {
      LineGraph lg = getGraph(i);
      if (lg.datapoints.size()>0) {
        float y = lg.getWindowY(lg.getY(lg.getLatestDataPoint()));
        y = (Float.isNaN(y))?lg.gy+lg.gh+offY:y; 
        offset[i] = 0;
        drawn[i] = y;
        for (int j=0; j<i; j++) {
          if (abs(drawn[j]-drawn[i]) < textHeight) {
            if (drawn[j] < y) {
              offset[i] = offset[j];
              offset[j] -= textHeight - abs(drawn[j]+offset[j]-(drawn[i]+offset[i]));
            } 
            else { 
              offset[i] -= textHeight - abs(drawn[j]+offset[j]-(drawn[i]+offset[i]));
            }
          }
          if (abs(drawn[j]+offset[j] - (drawn[i] + offset[i])) < textHeight) {
            if (drawn[j] < y) {
              offset[i] = offset[j];
              offset[j] -= textHeight - abs(drawn[j]+offset[j]-(drawn[i]+offset[i]));
            } 
            else { 
              offset[i] -= textHeight - abs(drawn[j]+offset[j]-(drawn[i]+offset[i]));
            }
            
          }
        }
      }
    }
  }


  void drawLabels(float drawn[], float offset[]) {
    for (int i=0; i<graphs.size(); i++) {
      LineGraph lg = getGraph(i);
          fill(lg.lineColor);

      if (lg.datapoints.size()>0) {
        String number = " "+int(lg.getLatestDataPoint())+"  ";
        float y = lg.getWindowY(lg.getY(lg.getLatestDataPoint()));
        y = drawn[i];
        text(number,lg.getWindowX(lg.gw)+labelLineWidth,y+offset[i] + textHeight/2);
        text(lg.label,lg.getWindowX(lg.gw) + textWidth(number)+labelLineWidth,y+offset[i] + textHeight/2);
        stroke(160);
        line(lg.getWindowX(lg.gw),y,lg.getWindowX(lg.gw)+labelLineWidth,y+offset[i]);
      }
    }

  }

}


class LineGraph {
  float gx,gy,gw,gh;
  color lineColor;
  float maxV,minV;
  boolean maxSet = false;
  boolean minSet = false;
  int lastCalcMin = -1;
  int lastCalcMax = -1;
  String label;
  float offX = -width/2, offY = -height/2;

  ArrayList datapoints = new ArrayList();

  public LineGraph(float _x, float _y, float _w, float _h, color c, String _label) {
    gx = _x; 
    gy = _y; 
    gw = _w; 
    gh = _h;  
    lineColor = c;
    label = _label;
  }

  void addDataPoint(float f) {
    datapoints.add(new Float(f));

  }
  
  float getDataPoint(int i) {
      return ((Float) datapoints.get(i)).floatValue();
  }
  
  float getLatestDataPoint() {
    return getDataPoint(datapoints.size()-1);
  }

  void setMax(float max) {
    maxV = max;
    maxSet = true;
  }

  void setMin(float min) {
    minV = min;
    minSet = true;
  }

  float getMaxFromData() {
    if (datapoints.size() == lastCalcMax) return maxV;
    float best=0;
    float cur;
    for (int i=0; i<datapoints.size(); i++) {
      cur = getDataPoint(i);
      if (i==0 || best < cur) best = cur; 
    }
    maxV = best;
    lastCalcMax = datapoints.size();
    return best;
  }

  float getMinFromData() {
    float best=0;
    float cur;
    for (int i=0; i<datapoints.size(); i++) {
      cur = getDataPoint(i);
      if (i==0 || best > cur) best = cur; 
    }
    minV = best;
    lastCalcMin = datapoints.size();
    return best;
  }
  
  float getMax() {
    if (maxSet || datapoints.size() == lastCalcMax) return maxV;
    getMaxFromData();
    return maxV;
  }
  
  float getMin() {
    if (minSet || datapoints.size() == lastCalcMin) return minV;
    getMinFromData();
    return minV;
  }

  float dataHeight() { return getMax() - getMin(); }
  float getY(float dataY) { return (dataY - getMin())/dataHeight()*gh; }
  float getWindowX(float x) { return x+gx+offX; }
  float getWindowY(float y) { return -y+gy+gh+offY; }
   
  void draw() {
    if (datapoints.size() == 0) return;

    fill(red(lineColor),green(lineColor),blue(lineColor),50);
    //noFill();
    stroke(lineColor);   
    float yVal=0;

    float xstep = gw/((datapoints.size()==1)?1:datapoints.size()-1);
    beginShape();
    vertex(getWindowX(0),getWindowY(0));
    for (int i=0; i<datapoints.size(); i++) {
      yVal =  getY(getDataPoint(i));
      vertex(getWindowX(xstep*(i)),getWindowY(yVal));
      if (datapoints.size() == 1) vertex(getWindowX(xstep*(i+1)),getWindowY(yVal));
    }
    vertex(getWindowX(gw),getWindowY(0));
    vertex(getWindowX(1),getWindowY(0));
    endShape();
  }
  
  void drawGrid(color c1, color c2) {
    int minorPerMajor = 6;
    int minPerMinor = 4;
    float xstep = gw/((datapoints.size()==1)?1:datapoints.size()-1);
    for (int i=0; i<datapoints.size(); i++) {
      if (i%minorPerMajor==0) {
        stroke(c1);
      line(getWindowX(xstep*(i)),getWindowY(0),getWindowX(xstep*i),getWindowY(gh*1.0));
      }
      else if (xstep>minPerMinor) {
        stroke(c2);
        line(getWindowX(xstep*(i)),getWindowY(0),getWindowX(xstep*i),getWindowY(gh*1.0));
      }
    }
    stroke(c2);
    rect(getWindowX(0),getWindowY(gh),gw,gh);    
  }
}