import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.Toolkit;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

import javax.swing.JComponent;

import java.text.DecimalFormat;
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;

/**
 * @author grom
 */
public class Animation extends JComponent implements Runnable {
	private static final long serialVersionUID = 9214955127889918259L;

	/**
	 * Number of frames with a delay of 0 ms before the animation thread yields
	 * to other running threads.
	 */
	private static final int NO_DELAYS_PER_YIELD = 16;


	/**
	 * Number of frames that can be skipped in any one animation loop. i.e the games
	 * state is updated but not rendered
	 */
	private static final int MAX_FRAME_SKIPS = 5;

	private Ball[] balls;

	private long period; // The amount of time in nanoseconds allocated to each frame

	public Animation(int width, int height, long period) {
		setOpaque(true);
		setBackground(Color.WHITE);
		setSize(width, height);
		setPreferredSize(new Dimension(width, height));

		this.period = period;

		List<Ball> ballList = new ArrayList<Ball>();
		ballList.add(new Ball(this, 10, 10, 0.5, 0.2, Color.BLUE));
		ballList.add(new Ball(this, 30, 30, 0.3, 0.1, Color.GREEN));
		ballList.add(new Ball(this, 150, 150, -0.2, -0.3, Color.RED));
		ballList.add(new Ball(this, 300, 440, -0.3, -0.4, Color.CYAN));
		ballList.add(new Ball(this, 600, 10, 0.3, 0.3, Color.GRAY));
		ballList.add(new Ball(this, 10, 460, 0.1, 0.2, Color.MAGENTA));
		ballList.add(new Ball(this, 50, 50, 0.3, 0.2, Color.ORANGE));
		ballList.add(new Ball(this, 620, 30, -0.4, -0.2, Color.YELLOW));
		ballList.add(new Ball(this, 10, 330, 0.2, 0.3, Color.PINK));

		balls = (Ball[]) ballList.toArray(new Ball[0]);

		initStats();
		setFocusable(true);
		requestFocus();
		readyForTermination();
	}
	
	 private void readyForTermination() {
		addKeyListener(new KeyAdapter() {
			// listen for esc, q, end, ctrl-c on the canvas to
			// allow a convenient exit from the full screen configuration
			public void keyPressed(KeyEvent e) {
				int keyCode = e.getKeyCode();
				if ((keyCode == KeyEvent.VK_ESCAPE)
						|| (keyCode == KeyEvent.VK_Q)
						|| (keyCode == KeyEvent.VK_END)
						|| ((keyCode == KeyEvent.VK_C) && e.isControlDown())) {
					isRunning = false;
				}
			}
		});
	}
	 
	private Thread animator; // Thread for performing the animation
	 
	public void start() {
		// initialise and start the thread
		if (animator == null || !isRunning) {
			animator = new Thread(this);
			animator.start();
		}
	}

	private volatile boolean isPaused = false;
	private volatile boolean isRunning = false;

	public void pause() {
		isPaused = true;
	}

	public void resume() {
		isPaused = false;
	}

	public void stop() {
		isRunning = false;
	}

	public void run() {
		long beforeTime, afterTime, timeDiff, sleepTime, lastRunTime, delta;
		long overSleepTime = 0L;
		int noDelays = 0;
		long excess = 0L;

		Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		isRunning = true;

		gameStartTime = System.nanoTime();
		prevStatsTime = gameStartTime;
		beforeTime = gameStartTime;
		lastRunTime = gameStartTime;

		while (isRunning) {
			delta = System.nanoTime() - lastRunTime; // How long since we last execute the main game loop
			lastRunTime = System.nanoTime();
			nextFrame(delta/1000000L);
			updateDisplay();

			afterTime = System.nanoTime();
			timeDiff = afterTime - beforeTime;
			sleepTime = (period - timeDiff) - overSleepTime;

			if (sleepTime > 0) {
				if (sleepTime > 1000000L) { // Don't try to sleep for any less then 1ms
					try {
						Thread.sleep(sleepTime / 1000000L /* nanosecs -> ms */);
					} catch (InterruptedException ex) {
						// do nothing
					}
					overSleepTime = (System.nanoTime() - afterTime) - sleepTime;
				} else {
					overSleepTime = 0L;
				}
			} else { // sleepTime <= 0; the frame took longer than the period
				excess -= sleepTime;  // store excess time value
				overSleepTime = 0L;

				if (++noDelays >= NO_DELAYS_PER_YIELD) {
					Thread.yield();   // give another thread a chance to run
					noDelays = 0;
				}
			}

			beforeTime = System.nanoTime();

			/*
			 * If frame animation is taking too long, update the game state
			 * without rendering it, to get the updates/sec nearer to the
			 * required FPS.
			 */
			int skips = 0;
			while ((excess > period) && (skips < MAX_FRAME_SKIPS)) {
				excess -= period;
				nextFrame(period/1000000L); // update state but don't render
				skips++;
			}
			framesSkipped += skips;

			updateStats();
		}
		cleanup();
	}
	
	public void cleanup() {
		isRunning = false;
		System.exit(0);
	}

	/**
	 * Creates the next frame
	 */
	public void nextFrame(double t) {
		if (isPaused) return;

		long startTime = System.nanoTime();

		double rt = t; // remaining frame time
		boolean isCollision = false;

		do {
			isCollision = false;

			// t is the time of the earliest collision.
			// if t == rt then there are either no collisions
			// or collision occured at time rt
			// Since only the earliest collision needs to be found,
			// the collision test are performed for the current
			// time of the earliest collision (t).

			// Test for wall collisions
			for (int i = 0; i < balls.length; i++) {
				t = Math.min(t, balls[i].testWallCollision(t));
			}

			// Test for ball collisions
			// collision are added to the head of this list
			List<Collision> collisions = new LinkedList<Collision>();
			Ball a, b;
			for (int i = 0; i < balls.length; i++) {
				a = balls[i];
				for (int j = i+1; j < balls.length; j++) {
					b = balls[j];
					t = Math.min(t, a.testBallCollision(b, t, collisions));
				}
			}

			// Move the balls
			for (int i = 0; i < balls.length; i++) {
				balls[i].move(t);
			}

			// Handle the collisions that occured
			// NOTE: It is possible that two collision occurred at the
			// same time. Therefore the collision list is iterated
			// until we get to a collision that occured after the
			// time of the first collision
			for (Collision c : collisions) {
				if (c.t == t) {
					c.handle();
					isCollision = true;
				} else {
					break;
				}
			}

			// calculate frame time renaming
			t = rt - t;
			rt = t;

		// continue updating frame if there was a collision and the frame period has not expired
		} while(isCollision && rt > 0 && System.nanoTime() - startTime < period);
	}

	private void renderFrame(Graphics2D g2d) {
		// clear screen in background
		g2d.setColor(getBackground());
		g2d.fillRect(0, 0, this.getWidth(), this.getHeight());

		g2d.setRenderingHint(
			RenderingHints.KEY_ANTIALIASING,
			RenderingHints.VALUE_ANTIALIAS_ON);

		for (int i = 0; i < balls.length; i++) {
			balls[i].paint(g2d);
		}

		drawStats(g2d);
	}

	// off screen rendering
	private Graphics dbg;
	private Image dbImage = null;

	private void updateDisplay() {
	    if (dbImage == null) {
	    	// Create buffer image
			dbImage = createImage(getWidth(), getHeight());
			if (dbImage == null) {
				System.out.println("dbImage is null");
				return;
			} else {
				dbg = dbImage.getGraphics();
			}
		}

	    // Render frame to off-screen buffer
	    renderFrame((Graphics2D) dbg);

		// Use active rendering
	    Graphics g;
		try {
			g = this.getGraphics();
			if ((g != null) && (dbImage != null)) {
				g.drawImage(dbImage, 0, 0, null);
				Toolkit.getDefaultToolkit().sync();  // sync the display on some systems
				g.dispose();
			}
		} catch (Exception e) {
			System.out.println("Graphics context error: " + e);
		}
	}


	// used for gathering statistics
	private static final long MAX_STATS_INTERVAL = 1000000000L; // record (roughly) every 1 second
	private static final int NUM_FPS = 10; // number of FPS values stored to get an average

	private long statsInterval = 0L;    // in ns
	private long prevStatsTime;
	private long totalElapsedTime = 0L;
	private long gameStartTime;

	private long frameCount = 0;
	private double fpsStore[];
	private long statsCount = 0;
	private double averageFPS = 0.0;

	private long framesSkipped = 0L;
	private long totalFramesSkipped = 0L;
	private double upsStore[];
	private double averageUPS = 0.0;

	private void initStats() {
		fpsStore = new double[NUM_FPS];
		upsStore = new double[NUM_FPS];
		for (int i = 0; i < NUM_FPS; i++) {
			fpsStore[i] = 0.0;
			upsStore[i] = 0.0;
		}
	}

	/**
	 * The statistics: - the summed periods for all the iterations in this
	 * interval (period is the amount of time a single frame iteration should
	 * take), the actual elapsed time in this interval, the error between these
	 * two numbers; - the total frame count, which is the total number of calls
	 * to run(); - the frames skipped in this interval, the total number of
	 * frames skipped. A frame skip is a game update without a corresponding
	 * render; - the FPS (frames/sec) and UPS (updates/sec) for this interval,
	 * the average FPS & UPS over the last NUM_FPSs intervals.
	 *
	 * The data is collected every MAX_STATS_INTERVAL (1 sec).
	 */
	private void updateStats() {
		frameCount++;
		statsInterval += period;

		if (statsInterval >= MAX_STATS_INTERVAL) { // record stats every
			// MAX_STATS_INTERVAL
			long timeNow = System.nanoTime();

			long realElapsedTime = timeNow - prevStatsTime; // time since last
			// stats collection
			totalElapsedTime += realElapsedTime;

			totalFramesSkipped += framesSkipped;

			double actualFPS = 0; // calculate the latest FPS and UPS
			double actualUPS = 0;
			if (totalElapsedTime > 0) {
				actualFPS = (((double) frameCount / totalElapsedTime) * 1000000000L);
				actualUPS = (((double) (frameCount + totalFramesSkipped) / totalElapsedTime) * 1000000000L);
			}

			// store the latest FPS and UPS
			fpsStore[(int) statsCount % NUM_FPS] = actualFPS;
			upsStore[(int) statsCount % NUM_FPS] = actualUPS;
			statsCount = statsCount + 1;

			double totalFPS = 0.0; // total the stored FPSs and UPSs
			double totalUPS = 0.0;
			for (int i = 0; i < NUM_FPS; i++) {
				totalFPS += fpsStore[i];
				totalUPS += upsStore[i];
			}

			if (statsCount < NUM_FPS) { // obtain the average FPS and UPS
				averageFPS = totalFPS / statsCount;
				averageUPS = totalUPS / statsCount;
			} else {
				averageFPS = totalFPS / NUM_FPS;
				averageUPS = totalUPS / NUM_FPS;
			}

			framesSkipped = 0;
			prevStatsTime = timeNow;
			statsInterval = 0L; // reset
		}
	}

	private DecimalFormat df = new DecimalFormat("0.##");

	private void drawStats(Graphics g) {
	    // report frame count & average FPS and UPS at top left
		g.setColor(Color.GRAY);
		g.drawString("Average FPS/UPS: " + df.format(averageFPS) + ", "
				+ df.format(averageUPS), 20, 25);
		g.drawString("Frames skipped: " + totalFramesSkipped, 20, 50);
	}

	// Overrides for performance

	public boolean isOpaque() {
		return true;
	}

	public void paint(Graphics g) {
	}

	public void paintComponent(Graphics g) {
	}

	public void paintImmediately(int x, int y, int w, int h) {
	}

	public void paintImmediately(java.awt.Rectangle r) {
	}

	public void validate() {
	}

	public void revalidate() {
	}

	public void repaint(long tm, int x, int y, int width, int height) {
	}

	public void repaint(java.awt.Rectangle r) {
	}

	protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
	}

	public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
	}

	public void updateUI() {
	}
}