import java.applet.Applet;
import java.util.Random;
import java.awt.*;

public class RANDeds1d extends Applet 
{
  Panel mypanel = new Panel();
  EDS1 mycanvas = new EDS1(this);
  Label mylabel = new Label("#steps:",Label.RIGHT);
  Button redrawButton = new Button("New Path");
  Button contButton = new Button("Cont");
  Button stopButton = new Button("Stop");
  GridBagLayout mylayout = new GridBagLayout();
  GridBagConstraints c = new GridBagConstraints();
  TextField mytextfield = new TextField(6);
  Checkbox mycheckbox1 = new Checkbox("Random Start",null,true);

  public void init() 
    {
      // Fisrt of all, construct the GUI
      setLayout(mylayout);
      setFont(new  Font("Helvetica",  Font.PLAIN,  10));
      mycanvas.resize(300,300);
      c.fill = GridBagConstraints.VERTICAL;
      c.gridheight = 10;
      c.gridwidth  = 10;
      c.gridx = 0;
      c.gridy = 0;
      mylayout.setConstraints(mycanvas,c);
      add(mycanvas); 
      c.fill = GridBagConstraints.HORIZONTAL;
      c.gridheight = 1;
      c.gridwidth  = 5;
      c.gridx = 11;
      c.gridy = 0;
      c.insets = new Insets(0,2,0,0);
      mylayout.setConstraints(mycheckbox1,c);
      add(mycheckbox1);
      c.gridy = 2;
      mylayout.setConstraints(mypanel,c);
      mypanel.add(mylabel);
      mytextfield.setText("1000");
      mycanvas.nbpoints = 1000;
      mypanel.add(mytextfield);
      add(mypanel);
      c.gridy = 3;
      mylayout.setConstraints(redrawButton,c);
      add(redrawButton);
      c.gridy = 4;
      mylayout.setConstraints(stopButton,c);
      add(stopButton);
      c.gridy = 5;
      mylayout.setConstraints(contButton,c);
      add(contButton);
      show(); 
      validate(); 

    }

  public boolean action(Event e, Object arg) 
    {
      Object target = e.target;
      String str;

      if(target==mytextfield) 
	{
	  // Get new value of nbpoints
	  str = mytextfield.getText();
	  mycanvas.nbpoints = (Integer.parseInt(str));
	  return true;
	}

      if(target==redrawButton)
	{
	  // Start a new walk
	  mycanvas.stop();
	  mycanvas.currentpoint=0;
	  str = mytextfield.getText();
	  mycanvas.nbpoints = (Integer.parseInt(str));
	  mycanvas.frozen = false;
	  mycanvas.start();
	  return true;
	}

      if(target==contButton)
	{
	  // stop and restart where we were
	  mycanvas.stop();
	  if(mycanvas.currentpoint>=mycanvas.nbpoints) 
	    mycanvas.currentpoint=1;
	  mycanvas.frozen = false;
	  mycanvas.start();
	  return true;
	}

      if(target==stopButton)
	{
	  // stop walking 
	  mycanvas.stop();
	  return true;
	}
	    
      // change some parameters...

      if(target==mycheckbox1)
	{
	  mycanvas.randstart = !mycanvas.randstart;
	  return true;
	}

      return false;
    }
      
}

// Here is the part concerning the EDS

class myedsclass extends Eds
{
  float b(float x, float t) /* Ito drift */
  {
    return (float) 0.0;
  }
  
  float sig(float x,float t)
  {
    if (x>=0.0)
      {
	return (float) Math.sqrt(x);
      }
    else
      { 
	return (float) 0.0;
      }
  }
  
  float dsigdx(float x,float t)
  {
    if (x>=0.0)
      {
	return (float) (-0.5/Math.sqrt(x));
      }
    else
      { 
	return (float) 0.0;
      }
  }

  float a(float x, float t)
  {
    return t; //not used here
  }
}

class EDS1 extends Canvas implements Runnable
{ // Class EDS1
  // Walk variables
  int nbpoints = 0;
  int currentpoint = 0;
  boolean randstart = true;
  int y0; //starting point
  int ix,iy,iy1; //current point
  float fx,fy,fy1;
  int mx,my; //max coord. of the canvas

  float h,sd;

  // Image buffers 
  Dimension offDimension;
  Image offImage,offImage1,offImage2;
  Graphics offGraphics,offGraphics1,offGraphics2;

  // thread controls
  boolean frozen = true;
  Thread drawThread = null;

  // container from where to get events
  Container control;

  // Random generator
  Random rand = new Random(45682);

  //Eds themselves...
  myedsclass eds1 = new myedsclass(),eds2 = new myedsclass();

  public EDS1(Container control)
  {
    super();
    this.control = control;
  }

  public void init()
  {
    Graphics g = getGraphics();

    // Draw something in canvas
    g.setColor(Color.pink);
    g.fillRect(1,1,size().width - 2, size().height - 2);
    g.setColor(Color.black);
    g.drawRect(0, 0, size().width - 1, size().height - 1);
  }

  public boolean mouseDown(Event e, int x, int y) 
  {
    Graphics g = getGraphics();
    Object target = e.target;

    // New starting point in canvas
    if(!randstart)
      {
	// store new starting point
	y0=y;

	fy = y;
	fy1 = y;
	
	// start walk
	stop();
	currentpoint = 0;
	frozen = false;
	start();
      }
    return true;
  }

  // (Re)Start the walk
  public void start()
  {
    Graphics g = getGraphics();
    
    if(frozen)
      {
	//Do nothing.  The user has requested that we
	//stop walking around.
      } 
    else 
      {
	//start walk
	if (drawThread == null) 
	  {
	    drawThread = new Thread(this,"walk");
	  }
	drawThread.start();
      }
  }

  public void stop()
  {
    //Stop the drawing thread.
    drawThread = null;
  }

  // Random walk iteration
  public void run()
  {
    float r,dw,dwc;
    Dimension d = size();
    int ny,ny1;
    int i;

    //Just to be nice, lower this thread's priority
    //so it can't interfere with other processing going on.
    Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

    h = (float) 0.001;
    sd = (float) Math.sqrt(h);
    eds1.method = Eds.MILSHTEIN;
    eds2.method = Eds.MILSHTEIN;


    //This is the animation loop.
    while (Thread.currentThread() == drawThread) 
      {
	// If first iteration
	if(currentpoint==0)
	  {
	    // erase previous walk
	    update(getGraphics());

	    mx = d.width;
	    my = d.height;
	    if(randstart)
	      {
		y0 = 1 + (int) (rand.nextFloat()*(my-1));
	      }
	    
	    currentpoint = 0;
	    ix = mx-10;
	    iy = y0;
	    iy1 = y0;
	    fy = y0;
	    fy1 = y0;
	  }
	
	//Advance the walk
	if(currentpoint<nbpoints)
	  {
	    currentpoint++;

	    // walk next step Milshtein method
	    fy = (my-10-fy)/50;
	    fy1 = (my-10-fy1)/50;
	    dwc = 0;
	    for(i=0;i<100;i++)
	      {
		dw = (float)rand.nextGaussian()*sd;
		dwc += dw;
		fy =eds1.oneStep(fy,h,dw,(float)(currentpoint*h));
	      }
	    //fy = euler(fy,h*100,dwc,(float)(currentpoint*h));
	    fy1 = eds1.oneStep(fy1,h*100,dwc,(float)(currentpoint*h));
	    fy = my-10-50*fy;
	    fy1 = my-10-50*fy1;
	    ny = (int) fy;
	    ny1 = (int) fy1;

	    //current point on buffer
	    offGraphics1.setColor(Color.red);
	    offGraphics1.drawLine(ix,iy,ix,ny);
	    offGraphics1.setColor(Color.black);
	    offGraphics1.drawLine(ix,my-10,ix,my-10);
	    offGraphics1.setColor(Color.blue);
	    offGraphics1.drawLine(ix,iy1,ix,ny1);

	    // Srawling
	    offGraphics2.setColor(Color.pink);
	    offGraphics2.drawImage(offImage1,-1,0, this);
	    offGraphics2.fillRect(mx-10,0,9,d.height - 1);
	    offGraphics.drawImage(offImage2, 0, 0, this);
	    offGraphics.setColor(Color.black);
	    offGraphics.drawRect(0, 0, d.width - 1,d.height - 1);
	    offGraphics.drawLine(mx,iy+3,mx-10,iy);
	    offGraphics.drawLine(mx,iy-3,mx-10,iy);
	    offGraphics.drawLine(mx,iy1+3,mx-10,iy1);
	    offGraphics.drawLine(mx,iy1-3,mx-10,iy1);
	    offGraphics.setColor(Color.orange);
	    offGraphics.fillOval(ix-3,iy-3,6,6);
	    offGraphics.fillOval(ix-3,iy1-3,6,6);
	    repaint();
	    offGraphics1.drawImage(offImage2, 0, 0, this);

	    iy = ny;
	    iy1 = ny1;
	  }
	else
	  {
	    stop();
	  }

       	try 
	  {
	    drawThread.sleep(30);
	  } 
	catch (InterruptedException e)
	  {
	  }
	  
      }
  }

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

  public void update(Graphics g)
  {
    Dimension d = size();

    //Create the offscreen graphics context, if no good one exists.
    if ( (offGraphics == null)
	 || (d.width != offDimension.width)
	 || (d.height != offDimension.height) ) 
      {
	offDimension = d;
	offImage = createImage(d.width, d.height);
	offGraphics = offImage.getGraphics();
	offImage1 = createImage(d.width, d.height);
	offGraphics1 = offImage1.getGraphics();
	offImage2 = createImage(d.width, d.height);
	offGraphics2 = offImage2.getGraphics();
      }
    
    if(currentpoint==0)
      {
	// Initialize buffers
	offGraphics.setColor(Color.pink);
	offGraphics.fillRect(1,1,d.width - 2,d.height - 2);
	offGraphics.setColor(Color.black);
	offGraphics.drawRect(0, 0,d.width - 1,d.height - 1);
	offGraphics.setColor(Color.red);
	offGraphics1.setColor(Color.pink);
	offGraphics1.fillRect(1,1,d.width - 2,d.height - 2);
	offGraphics1.setColor(Color.red);
	offGraphics2.setColor(Color.pink);
	offGraphics2.fillRect(1,1,d.width - 2,d.height - 2);
	g.drawImage(offImage, 0, 0, this);
      }
    else
      {
	// Display current image
	g.drawImage(offImage, 0, 0, this);
      }
  }
  
}