import javax.swing.event.EventListenerList;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

// TODO: Loads of threads in this class, make sure everything is thread safe.

public class PunchingBag implements Runnable {
	boolean ledsChanged = false;
	final public int ledHeight = 20;
	final public int ledWidth = 9;
	private byte[] rawLeds = new byte[6 * 8];
	private Colour[][] leds = new Colour[ledWidth][ledHeight];
	private byte[] ledGridIntensities = new byte[6];
	final public int buttonHeight = 19;
	final public int buttonWidth = 8;
	private boolean[][] buttons = new boolean[buttonWidth][buttonHeight];
	boolean buttonsChanged = false;

	private ArrayList<Effect> runningEffects = new ArrayList<Effect>();
	
	ButtonArduino buttonArduino = new ButtonArduino();

	public enum Colour {
		None, Red, Yellow, Green
	};

	// Is there a better class for this? One that it is not a swing class.
	private EventListenerList buttonListenerList = new EventListenerList();
	private EventListenerList ledListenerList = new EventListenerList();
	private EventListenerList accelListenerList = new EventListenerList();


	public PunchingBag() {
		new Thread(this).start();
	}

	/**
	 * Adds an <code>ActionListener</code> to the button.
	 * 
	 * @param l
	 *            the <code>ActionListener</code> to be added
	 */
	public void addButtonListener(ButtonListener l) {
		buttonListenerList.add(ButtonListener.class, l);
	}

	public void addLEDChangeListener(LEDListener l) {
		ledListenerList.add(LEDListener.class, l);
	}
	
	public void addLEDChangeListener(AccelListener l) {
		accelListenerList.add(AccelListener.class, l);
	}

	public Colour getLED(int x, int y) {
		return leds[x][y];
	}

	public boolean setLED(int x, int y, Colour colour) {
		if (x >= 0 && x < ledWidth && y >= 0 && y < ledHeight) {
			if (leds[x][y] != colour) {
				leds[x][y] = colour;
				ledsChanged = true;

			}
			return true;
		} else {
			return false;
		}
	}

	void CircleExpand(int x, int y, int intensity) {
		runningEffects.add(new CircleExpand(x, y, 100));
	}

	abstract class Effect {
		long lastRefresh = 0;
		boolean stop = false;

		// int refreshRate = 60; // Times per second to refresh

		public void stop() {
			stop = true;
		}

		abstract public void draw();
	}

	class CircleExpand extends Effect {
		final int x;
		final int y;
		int intensity;
		boolean drawnSomething = true;

		float currentRadius = 0;

		public CircleExpand(int x, int y, int intensity) {
			this.x = x;
			this.y = y;
			this.intensity = intensity;
		}

		public void draw() {
			Colour colour;

			if (intensity >= 10) {
				colour = Colour.Red;
			} else if (intensity >= 5) {
				colour = Colour.Yellow;
			} else {
				colour = Colour.Green;
			}

			intensity -= 5;

			currentRadius += 0.1 + 0.1 + (currentRadius / 20);
			// currentRadius += 0.01;
			// longhand: currentRadius = currentRadius + 0.1 + (currentRadius /
			// 10);

			if (!DrawEllipse(x, y, (int) currentRadius, (int) currentRadius,
					colour))
				stop = true;
		}

	}

	public boolean DrawEllipse(int x, int y, int radx, int rady, Colour colour) {
		if (radx == 0 && rady == 0) {
			return setLED(x, y, colour);
		}

		boolean doneSomething = false;

		int dx = 0, dy = rady; /* first quadrant from top left to bottom right */
		int a2 = radx * radx, b2 = rady * rady;
		int err = b2 - (2 * rady - 1) * a2, e2; /* error value in the first step */

		do {
			if (setLED(x + dx, y + dy, colour)) {/* I. Quadrant */
				doneSomething = true;
			}
			if (setLED(x - dx, y + dy, colour)) {/* II. Quadrant */
				doneSomething = true;
			}
			if (setLED(x - dx, y - dy, colour)) {/* III. Quadrant */
				doneSomething = true;
			}
			if (setLED(x + dx, y - dy, colour)) {/* IV. Quadrant */
				doneSomething = true;
			}

			e2 = 2 * err;
			if (e2 < (2 * dx + 1) * b2) {
				dx++;
				err += (2 * dx + 1) * b2;
			}
			if (e2 > -(2 * dy - 1) * a2) {
				dy--;
				err -= (2 * dy - 1) * a2;
			}
		} while (dy >= 0);

		while (dx++ < radx) { /* correction for flat ellipses (b=1) */
			if (setLED(x + dx, y, colour)) {
				doneSomething = true;
			}
			if (setLED(x - dx, y, colour)) {
				doneSomething = true;
			}
		}
		return doneSomething;
	}

	private void calculateRawLeds() {
		for (int y = 0; y <= 18; y++) {
			for (int x = 0; x <= 6; x++) {
				if ((y % 2) == 0) {
					if (leds[x][y] == Colour.Green
							|| leds[x][y] == Colour.Yellow) {
						rawLeds[(int) Math.floor(y / 4)] = (byte) (rawLeds[(int) Math
								.floor(y / 4)] | (1 << (7 - x)));
					}
				} else {
					if (leds[x][y] == Colour.Red || leds[x][y] == Colour.Yellow) {
						rawLeds[(int) Math.floor(y / 4)] = (byte) (rawLeds[(int) Math
								.floor(y / 4)] | (1 << (7 - x)));
					}
				}
			}
		}
		int x = 7;
		// TODO: Complete and test, or rethink the following?
		for (int startY = 0; startY <= 4; startY++) {
			for (int y = 0; y <= 3; y++) {
				if (leds[x][startY + (y * 4)] == Colour.Red
						|| leds[x][startY + (y * 4)] == Colour.Yellow) {
					rawLeds[(5 * 8) + startY] = (byte) (rawLeds[(int) Math
							.floor(y / 4)] | (1 << (7 - x)));
				}
				if (leds[x][y] == Colour.Green || leds[x][y] == Colour.Yellow) {
					rawLeds[(int) Math.floor(y / 4)] = (byte) (rawLeds[(int) Math
							.floor(y / 4)] | (1 << (7 - x)));
				}
			}
		}
	}

	/* Clears the led grid and stops all running effects */
	void clearLEDGrid() {
		/*
		 * for (Iterator<Effect> iter = runningEffects.iterator();
		 * iter.hasNext();) { ((Effect) iter.next()).stop(); }
		 */
		for (int x = 0; x < ledWidth; x++) {
			for (int y = 0; y < ledHeight; y++) {
				leds[x][y] = Colour.None;
			}
		}
		// Arrays.fill(leds,Colour.None);
	}

	public void setLEDGridIntensity(byte grid, byte intensity) {
		ledGridIntensities[grid] = intensity;
	}

	public void setLEDIntensities(byte intensity) {
		Arrays.fill(ledGridIntensities, intensity);
	}

	public void buttonPressed(int x, int y) {
		buttons[x][y] = true;
		buttonsChanged = true;
	}

	public void run() {
		while (true) {
			synchronized (runningEffects) { // Should prevent
				// ConcurrentModificationException's
				// (havent managed to produce one
				// though
				for (Iterator<Effect> iter = runningEffects.iterator(); iter
						.hasNext();) {
					Effect ef = (Effect) iter.next();
					if (ef.stop) {
						iter.remove();
					} else {// if ((ef.lastRefresh + (1000 / ef.refreshRate)) <=
						// Systems.currentTimeMillis()) {
						ef.draw();
						ef.lastRefresh = System.currentTimeMillis();
					}
				}
			}

			if (ledsChanged) {
				LEDListener[] LEDListeners = ledListenerList
						.getListeners(LEDListener.class);
				for (int i = 0; i < ledListenerList.getListenerCount(); i++) {
					LEDListeners[i].LEDchanged();
				}
			}

			if (buttonsChanged) {
				ButtonListener[] buttonListeners = buttonListenerList
						.getListeners(ButtonListener.class);
				for (int i = 0; i < buttonListenerList.getListenerCount(); i++) {
					for (int x = 0; x < buttonWidth; x++) {
						for (int y = 0; y < buttonHeight; y++) {
							if (buttons[x][y])
								buttonListeners[i].buttonPressed(x, y);
						}
					}
				}
			}

			// TODO: Hack?
			for (int x = 0; x < buttonWidth; x++) {
				for (int y = 0; y < buttonHeight; y++) {
					buttons[x][y] = false;
				}
			}

			// TODO: Hack?
			clearLEDGrid();

			try {
				Thread.sleep(1000 / 60);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}