import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import java.lang.Math;

public class StopTimea3 extends java.applet.Applet 
  implements Runnable {

  Canvas oscillators;
  Label reactTimeLabel, vZeroLabel, muLabel,
        reactTimeS, vZeroS;
  TextField mu;
  Button Start, Reset;
  Thread runner;
  Scrollbar reactTimescroll, vZeroscroll;
  int reactTime, vZero, ballDiameter, ypos;
  int[] xpos = new int[2];
  double[] x = new double[2];
  double coeff, currentV, t, reactT, intcurrentV, 
         reactDist, totalDist, currentDist;
  Image offscreenImg;
  Graphics offscreenG;

  boolean startFlag;
  boolean pauseFlag;

  void buildConstraints(GridBagConstraints gbc, int gx, int gy, 
      int gw, int gh,
      int wx, int wy) {
	gbc.gridx = gx;
	gbc.gridy = gy;
	gbc.gridwidth = gw;
	gbc.gridheight = gh;
	gbc.weightx = wx;
	gbc.weighty = wy;
  }

  public void init() {
    GridBagLayout gridbag = new GridBagLayout();
    GridBagConstraints constraints = new GridBagConstraints();
    setLayout(gridbag);

    // Initial velocity text
    buildConstraints(constraints, 0, 0, 1, 1, 20, 5);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;
    Label vZeroLabel = new Label("Initial speed (km/hr):", Label.CENTER);
    gridbag.setConstraints (vZeroLabel, constraints);
    add(vZeroLabel);

    // Initial velocity scrollbar label
    buildConstraints(constraints, 2, 0, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    vZeroS = new Label("100", Label.LEFT);
    vZero = 100;
    gridbag.setConstraints (vZeroS, constraints);
    add(vZeroS);

    // Initial velocity scrollbar
    buildConstraints(constraints, 1, 0, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.WEST;
    vZeroscroll = new Scrollbar(Scrollbar.HORIZONTAL, 100, 10, 10, 160);
    gridbag.setConstraints (vZeroscroll, constraints);
    add(vZeroscroll);

    // reaction time text
    buildConstraints(constraints, 0, 1, 1, 1, 20, 5);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;
    Label reactTimeLabel = new Label("Reaction time (milliseconds):", Label.CENTER);
    gridbag.setConstraints (reactTimeLabel, constraints);
    add(reactTimeLabel);

    // reaction time scrollbar label
    buildConstraints(constraints, 2, 1, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    reactTimeS = new Label("10", Label.LEFT);
    reactTime = 10;
    gridbag.setConstraints (reactTimeS, constraints);
    add(reactTimeS);

    // reaction time scrollbar
    buildConstraints(constraints, 1, 1, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.WEST;
    reactTimescroll = new Scrollbar(Scrollbar.HORIZONTAL, 10, 10, 0, 500);
    gridbag.setConstraints (reactTimescroll, constraints);
    add(reactTimescroll);

    // mu label
    buildConstraints(constraints, 0, 2, 1, 1, 20, 5);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;
    Label mulabel = new Label("Coefficient of friction (between 0.4 and 2.0):", Label.RIGHT);
    gridbag.setConstraints (mulabel, constraints);
    add(mulabel);

    // mu textbox
    buildConstraints(constraints, 1, 2, 1, 1, 0, 0);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.CENTER;
    mu = new TextField("0.9", 6);
    coeff = 0.9;
    gridbag.setConstraints (mu, constraints);
    add(mu);

    // Start button
    buildConstraints(constraints, 0, 3 , 1, 1, 0, 10);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;
    Start = new Button("  Start  ");
    gridbag.setConstraints (Start, constraints);
    add(Start);

    // Reset button
    buildConstraints(constraints, 1, 3 , 1, 1, 0, 10);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.WEST;
    Reset = new Button("Reset");
    gridbag.setConstraints (Reset, constraints);
    add(Reset);

    // canvas
    buildConstraints(constraints, 0, 4, 3, 1, 0, 80);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    oscillators = new Canvas();
    gridbag.setConstraints (oscillators, constraints);
    add(oscillators);

    offscreenImg = createImage(this.size().width, this.size().height);
    offscreenG = offscreenImg.getGraphics();
  }

  public void start() {
    if (runner == null); {
      runner = new Thread(this);
      runner.start();
    }
  }

  public void stop() {
    if (runner != null) {
      runner.stop();
      runner = null;
    }
  }

  public void run() {

    double deltat, junk, g, accel, scale, maxTime;
    Double temp;
    deltat=0.1;
    scale = 1.88;
    g = 9.8;
    ypos = 300;

    while (true) {
      startFlag = false;
      pauseFlag = false;
      t = 0.0;
      intcurrentV = vZero/3.6;
      currentV = intcurrentV;
      reactT = reactTime/1000.0;
      currentDist = 0.0;

      temp = Double.valueOf(mu.getText());
      coeff = temp.doubleValue();
      if (coeff < 0.4) coeff = 0.4;
      if (coeff > 2.0) coeff = 2.0;

      accel = coeff*g;

      reactDist = intcurrentV*reactT;
      totalDist = reactDist + intcurrentV*intcurrentV / (2.0*accel);
      maxTime = reactT+intcurrentV/accel;

      x[0] = 10.0;
      xpos[0] = (int)(x[0]);
      x[1] = x[0];
      xpos[1] = (int)(x[1]);

      while (pauseFlag) {

        while (startFlag) { 
          t = t + deltat;

          if (t>maxTime) {
           t=maxTime;
          }

          if (t<reactT) {
           x[1]= x[0]+scale*intcurrentV*t;
          }
          else {
           currentDist = reactDist+(t-reactT)*(intcurrentV-0.5*accel*(t-reactT));
           x[1] = x[0]+scale*(currentDist);
           currentV = intcurrentV-accel*(t-reactT);
          }

          xpos[1] = (int)(x[1]);
          repaint();
          try { Thread.sleep(100); }
          catch (InterruptedException e) { }
       } 
    }

     repaint();
     try { Thread.sleep(1); }
     catch (InterruptedException e) { }
     }
  }

  public void update(Graphics g) {
    paint(g);
  }
     
  public void paint(Graphics g) {

   int i;

     // Draw background
   offscreenG.setColor(Color.lightGray);
   offscreenG.fillRect(0,0,600,199);
   offscreenG.setColor(Color.white);
   offscreenG.fillRect(0,200,600,200);

   // Draw mass
    offscreenG.setColor(Color.black);
    offscreenG.drawLine(5, ypos, 570, ypos);
    offscreenG.fillOval(xpos[1]+5,ypos-11,10,10);
    offscreenG.fillOval(xpos[1]+35,ypos-11,10,10);
    offscreenG.setColor(Color.red);
    offscreenG.fillRect(xpos[1],ypos-18,50,12);
    offscreenG.fillRect(xpos[1]+4,ypos-30,28,12);
    offscreenG.drawString("Time = " + t + " s", 20, 320);
    offscreenG.drawString("Distance covered = " + currentDist + " m", 20, 340);
    offscreenG.drawString("Speed = " + currentV + " m/s", 20, 360);
    offscreenG.setColor(Color.blue);
    offscreenG.drawString("Initial speed = " + intcurrentV + " m/s", 300, 320);
    offscreenG.drawString("Distance traveled before braking = " + reactDist + " m", 300, 340);
    offscreenG.drawString("Total stopping distance = " + totalDist + " m", 300, 360);
   g.drawImage(offscreenImg,0,0,this);
  }

  public void destroy() {
     offscreenG.dispose();
  }

  public boolean action (Event evt, Object arg) {

    if (evt.target instanceof Button) {

      if ((Button)evt.target == Reset) {     
          startFlag = false;
          pauseFlag = false;
          Start.setLabel("  Start  ");
      }

      else if ((Button)evt.target == Start) {

        if (Start.getLabel().equals("  Start  ")) {
          startFlag = true;
          pauseFlag = true;
          Start.setLabel("Pause");
        }

        else {
          startFlag = false;
          pauseFlag = true;
          Start.setLabel("  Start  ");
        }
      }
    }
    else return super.action(evt, arg);
    return true;
  }

  public boolean handleEvent(Event evt) {

    if (evt.target instanceof Scrollbar) {
      if ((Scrollbar)evt.target == reactTimescroll) {
        reactTime = ((Scrollbar)evt.target).getValue();
        reactTimeS.setText(String.valueOf(reactTime));
      }
      else if ((Scrollbar)evt.target == vZeroscroll) {
        vZero = ((Scrollbar)evt.target).getValue();
        vZeroS.setText(String.valueOf(vZero));
      }
	repaint();
    }
    else return super.handleEvent(evt);
    return true;
  }
}