package org.mn.omnifarious.applets.Koch;

import java.awt.Graphics;
import java.awt.Point;
import java.awt.Image;
import java.awt.Color;
import java.awt.Component;

class KochThread  extends Object implements Runnable
{
    private Image canvas_;
    Component display_;
    private int width_, height_;
    private Point tr1_, tr2_, tr3_;
    private double curx_, cury_;
    private java.util.Random rnumgen_;
    private int xpoints_[], ypoints_[];
    private int maxpoints_;

    public KochThread(Image canvas, int width, int height, Component display) {
	int xfill, yfill;

	display_ = display;
	canvas_ = canvas;
	width_ = width;
	height_ = height;
	maxpoints_ = (width_ * height_) / 40;
	xpoints_ = new int[maxpoints_];
	ypoints_ = new int[maxpoints_];
	tr1_ = new Point(width_ / 2, 0);
	tr2_ = new Point(0, height_ - 1);
	tr3_ = new Point(width_ - 1, height_ - 1);
	rnumgen_ = new java.util.Random();
	switch (rnumgen_.nextInt() % 3) {
	  case 0:
	      curx_ = xfill = tr1_.x;
	      cury_ = yfill = tr1_.y;
	      break;
	  case 1:
	      curx_ = xfill = tr2_.x;
	      cury_ = yfill = tr2_.y;
	      break;
	  default:
	  case 2:
	      curx_ = xfill = tr3_.x;
	      cury_ = yfill = tr3_.y;
	      break;
	}
	for (int i = 0; i < maxpoints_; ++i) {
	    xpoints_[i] = xfill;
	    ypoints_[i] = yfill;
	}
    }

    public void run() {
	Graphics g = canvas_.getGraphics();

	g.setColor(Color.white);
	g.fillRect(0, 0, width_, height_);
	g.setColor(Color.black);

	drawPoints(g);
    }

    private void drawPoints(Graphics g) {
	final int drawinc = 40;
	int curpointnum = 0;
	int[] xp, yp;

	xp = new int[drawinc];
	yp = new int[drawinc];
	while (true) {
	    for (int i = 0; i < drawinc; ++i) {
		int x = (int)(curx_ + 0.5);
		int y = (int)(cury_ + 0.5);

		xp[i] = x;
		yp[i] = y;

		switch ((rnumgen_.nextInt() / 64) % 11) {
		  case 0:
		  case 1:
		  case 2:
		  case 3:
		  case 4:
		      curx_ = (curx_ + tr1_.x) / 2.0;
		      cury_ = (cury_ + tr1_.y) / 2.0;
		      break;
		  case 5:
		  case 6:
		  case 7:
		  case 8:
		  case 9:
		      curx_ = (curx_ + tr2_.x) / 2.0;
		      cury_ = (cury_ + tr2_.y) / 2.0;
		      break;
		  default:
		  case 10:
		      curx_ = (curx_ + tr3_.x) / 2.0;
		      cury_ = (cury_ + tr3_.y) / 2.0;
		      break;
		}
	    }

	    if ((drawinc + curpointnum) < maxpoints_) {
		for (int i = 0; i < drawinc; ++i) {
		    xpoints_[curpointnum] = xp[i];
		    ypoints_[curpointnum] = yp[i];
		    ++curpointnum;
		}
	    } else {
		final int stop = maxpoints_ - curpointnum;

		for (int i = 0; i < stop; ++i) {
		    xpoints_[curpointnum] = xp[i];
		    ypoints_[curpointnum] = yp[i];
		    ++curpointnum;
		}
		curpointnum = 0;
		for (int i = stop; i < drawinc; ++i) {
		    xpoints_[curpointnum] = xp[i];
		    ypoints_[curpointnum] = yp[i];
		    ++curpointnum;
		}
	    }		    
	    synchronized (canvas_) {
		g.setColor(Color.white);
		g.fillRect(0, 0, width_ - 1, height_ - 1);
		g.setColor(Color.black);
		for (int i = 0; i < maxpoints_; ++i) {
		    g.drawLine(xpoints_[i], ypoints_[i],
			       xpoints_[i], ypoints_[i]);
		}
	    }
	    display_.repaint();
	}
    }
}

public class Koch extends java.applet.Applet
{
    Image triangle_;
    Thread makerthread_;
    KochThread dotmaker_;

    public void init() {
	java.awt.Dimension size = size();

	triangle_ = createImage(size.width, size.height);
	dotmaker_ = new KochThread(triangle_, size.width, size.height, this);
    }

    public void start() {
	if ((makerthread_ == null) || !makerthread_.isAlive()) {
	    makerthread_ = new Thread(dotmaker_);
	    makerthread_.start();
	}
    }

    public void stop() {
	if ((makerthread_ != null) && makerthread_.isAlive()) {
	    makerthread_.stop();
	}
	makerthread_ = null;
    }

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

    public void paint(Graphics g) {
	synchronized (triangle_) {
	    g.drawImage(triangle_, 0, 0, this);
	}
    }
}