import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.io.*;
import javax.imageio.*;
import javax.swing.*;

public class Canvas extends JPanel {
	public static final int TS_WIDTH = 144;
	public static final int TS_HEIGHT = 122;
	public static final int TS_DIGITS_Y = 33;
	public static final int TS_FACES_Y = 55;
	public static final int TS_MISC_Y = 82;
	public static final int TS_DIGIT_BACKDROP_X = 28;
	public static final int TS_COLOR_X = 70;
	public static final int BORDER_WIDTH = 12;
	public static final int BORDER_HEIGHT = 11;
	public static final int BOTTOM_HEIGHT = 12;
	public static final int TOP_BOX_HEIGHT = 33;
	public static final int TOP_PADDING = 15;
	public static final int FLAGS_PADDING = 16;
	public static final int TIMER_PADDING = 59;

	public final int ROWS;
	public final int COLS;
	public final int MINES;
	public final int WIDTH;
	public final int HEIGHT;

	private final JPanel BOARD_PANEL;
	private final NumberDisplay FLAGS_DISPLAY;
	private final NumberDisplay TIMER_DISPLAY;
	private final Face FACE;
	private final KeyListener SHIFT_KEY_LISTENER;
	private final Timer TIMER;
	private final Tile[][] BOARD;
	private final Image BACKGROUND_IMAGE;

	// The tile that the mouse is currently over
	private Tile currentTile;

	private boolean gameStarted;
	private boolean gameEnded;
	private boolean gameLost;
	private boolean holdingShift;
	private boolean leftMouseDown;
	private boolean rightMouseDown;
	private int numTilesLeft;
	private int numFlagsLeft;
	private int time;

	private void init() {
		currentTile = null;
		gameStarted = false;
		gameEnded = false;
		gameLost = false;
		holdingShift = false;
		leftMouseDown = false;
		rightMouseDown = false;
		numTilesLeft = ROWS * COLS - MINES;
		numFlagsLeft = MINES;
		time = 0;

		addKeyListener(SHIFT_KEY_LISTENER);

		FLAGS_DISPLAY.setNum(numFlagsLeft);
		TIMER_DISPLAY.setNum(time);
	}

	public Canvas(int rows, int cols, int mines, File skin) {
		ROWS = rows;
		COLS = cols;
		MINES = mines;
		WIDTH = Tile.SIZE * COLS + 2 * BORDER_WIDTH;
		HEIGHT = Tile.SIZE * ROWS + 2 * BORDER_HEIGHT + BOTTOM_HEIGHT + TOP_BOX_HEIGHT;

		BufferedImage tileset;
		try {
			tileset = ImageIO.read(skin);
			// Reject images that are too small to properly form the tileset
			if (tileset.getWidth() < TS_WIDTH || tileset.getHeight() < TS_HEIGHT)
				throw new IOException();
		} catch (IOException e) {
			// Just use an empty tileset if it didn't work out
			tileset = new BufferedImage(TS_WIDTH, TS_HEIGHT, BufferedImage.TYPE_INT_RGB);
		}

		BACKGROUND_IMAGE = getBackgroundImage(tileset);

		Image[] numberTiles = new Image[9];
		Image[] specialTiles = new Image[Tile.EXPLODED_MINE_INDEX + 1];
		for (int i = 0; i < 9; i++)
			numberTiles[i] = getTileFromSet(tileset, i, 0);
		for (int i = 0; i <= Tile.EXPLODED_MINE_INDEX; i++)
			specialTiles[i] = getTileFromSet(tileset, i, Tile.SIZE);

		BOARD = new Tile[ROWS][COLS];
		BOARD_PANEL = new JPanel(new GridLayout(ROWS, COLS));
		for (int r = 0; r < ROWS; r++) {
			for (int c = 0; c < COLS; c++) {
				BOARD[r][c] = new Tile(this, numberTiles, specialTiles);
				BOARD_PANEL.add(BOARD[r][c]);
			}
		}
		// Before doing anything else, we want each tile to know what tiles are
		// adjacent to them
		for (int r = 0; r < ROWS; r++) {
			for (int c = 0; c < COLS; c++) {
				// Liberal use of min/max to ensure we don't go out of bounds
				int rStart = Math.max(r - 1, 0);
				int rEnd = Math.min(r + 2, ROWS);
				int cStart = Math.max(c - 1, 0);
				int cEnd = Math.min(c + 2, COLS);
				for (int rAdj = rStart; rAdj < rEnd; rAdj++)
					for (int cAdj = cStart; cAdj < cEnd; cAdj++)
						if (rAdj != r || cAdj != c) // Ignore yourself
							BOARD[r][c].addAdjacentTile(BOARD[rAdj][cAdj]);
			}
		}

		Image[] digits = getImageSet(tileset, NumberDisplay.MINUS_INDEX, TS_DIGITS_Y,
				NumberDisplay.DIGIT_WIDTH, NumberDisplay.DIGIT_HEIGHT);
		Image numberDisplayBackdrop = tileset.getSubimage(TS_DIGIT_BACKDROP_X, TS_MISC_Y,
				NumberDisplay.BACKDROP_WIDTH, NumberDisplay.BACKDROP_HEIGHT);

		FLAGS_DISPLAY = new NumberDisplay(numberDisplayBackdrop, digits);
		TIMER_DISPLAY = new NumberDisplay(numberDisplayBackdrop, digits);
		FACE = new Face(this, getImageSet(tileset, Face.PRESSED_INDEX, TS_FACES_Y, Face.SIZE, Face.SIZE));

		SHIFT_KEY_LISTENER = new KeyListener() {
			// Shift+LMB chords, so we need some way of determining if the shift
			// key is being held.
			@Override
			public void keyPressed(KeyEvent e) {
				if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
					holdingShift = true;
					updateCurrentTile();
				}
			}

			@Override
			public void keyReleased(KeyEvent e) {
				if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
					holdingShift = false;
					updateCurrentTile();
				}
			}

			@Override
			public void keyTyped(KeyEvent e) {
			}

			private void updateCurrentTile() {
				if (currentTile != null)
					currentTile.updatePressedState();
			}
		};

		// 1 second delay
		TIMER = new Timer(1000, new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				// Can't display past 999 anyways
				if (time == 999) {
					TIMER.stop();
					return;
				}

				Sound.TICK.play();
				TIMER_DISPLAY.setNum(++time);
			}
		});

		// Null layout, for manual placement of all game components
		setLayout(null);
		Insets insets = getInsets();
		placeComponent(BOARD_PANEL, BORDER_WIDTH, 2 * BORDER_HEIGHT + TOP_BOX_HEIGHT, insets);
		placeComponent(FLAGS_DISPLAY, FLAGS_PADDING, TOP_PADDING, insets);
		placeComponent(TIMER_DISPLAY, WIDTH - TIMER_PADDING, TOP_PADDING, insets);
		placeComponent(FACE, (WIDTH - Face.SIZE) / 2, TOP_PADDING, insets);

		setPreferredSize(new Dimension(WIDTH, HEIGHT));
		setFocusable(true);

		init();
	}

	public void stop() {
		TIMER.stop();
		removeKeyListener(SHIFT_KEY_LISTENER);
	}

	public void restart() {
		if (!gameStarted)
			return;

		stop();
		init();
		for (Tile[] row : BOARD)
			for (Tile tile : row)
				tile.restart();
		BOARD_PANEL.repaint();
	}

	// Start the game if it's not already started
	public void tryStartGame(Tile startTile) {
		if (gameStarted)
			return;
		gameStarted = true;

		// Place all the mines after the the first tile was selected, in such a
		// way that the first selected tile must be blank
		for (int mineCount = 0; mineCount < MINES;) {
			int row = (int) (Math.random() * ROWS);
			int col = (int) (Math.random() * COLS);
			if (BOARD[row][col].makeMine(startTile))
				mineCount++;
		}

		TIMER.start();
	}

	public void postRevealCheck() {
		if (gameLost) {
			Sound.EXPLODE.play();
			stopGame();
			FACE.setFace(Face.DEAD_INDEX);
		} else if (numTilesLeft == 0) {
			Sound.WIN.play();
			// Automatically flag all remaining tiles on win
			FLAGS_DISPLAY.setNum(0);
			stopGame();
			FACE.setFace(Face.COOL_INDEX);
		}
	}

	public void modifyFlagCount(boolean addedFlag) {
		if (addedFlag)
			numFlagsLeft--;
		else
			numFlagsLeft++;
		FLAGS_DISPLAY.setNum(numFlagsLeft);
	}

	public void revealedSingleTile() {
		numTilesLeft--;
	}

	public void setLoseFlag() {
		gameLost = true;
	}

	public void setLeftMouseDown(boolean b) {
		if (gameEnded)
			return;

		leftMouseDown = b;
		if (leftMouseDown)
			FACE.setFace(Face.SHOCKED_INDEX);
		else
			FACE.setFace(Face.HAPPY_INDEX);
	}

	public void setRightMouseDown(boolean b) {
		rightMouseDown = b;
	}

	public boolean isLeftMouseDown() {
		return leftMouseDown;
	}

	public boolean isChording() {
		return holdingShift || rightMouseDown;
	}

	public Tile getCurrentTile() {
		return currentTile;
	}

	public void setCurrentTile(Tile tile) {
		currentTile = tile;
	}

	public boolean isGameLost() {
		return gameLost;
	}

	private static Image getTileFromSet(BufferedImage tileset, int n, int y) {
		return tileset.getSubimage(Tile.SIZE * n, y, Tile.SIZE, Tile.SIZE);
	}

	private Image[] getImageSet(BufferedImage tileset, int lastIndex, int y, int width, int height) {
		Image[] img = new Image[lastIndex + 1];
		int x = 0;
		for (int i = 0; i <= lastIndex; i++) {
			img[i] = tileset.getSubimage(x, y, width, height);
			x += width + 1;
		}
		return img;
	}

	// Create the background image, borders and all
	private BufferedImage getBackgroundImage(BufferedImage tileset) {
		// Get all the images out of the tileset, going row-by-row, hence tsY
		// marking the y-index of the current row
		int tsY = TS_MISC_Y;
		Image topLeftCorner = tileset.getSubimage(0, tsY, BORDER_WIDTH, BORDER_HEIGHT);
		Image topBorder = tileset.getSubimage(BORDER_WIDTH + 1, tsY, 1, BORDER_HEIGHT);
		Image topRightCorner = tileset.getSubimage(BORDER_WIDTH + 3, tsY, BORDER_WIDTH, BORDER_HEIGHT);
		tsY += BORDER_HEIGHT + 1;
		Image topLeftBorder = tileset.getSubimage(0, tsY, BORDER_WIDTH, 1);
		Image topRightBorder = tileset.getSubimage(BORDER_WIDTH + 3, tsY, BORDER_WIDTH, 1);
		tsY += 2;
		Image middleLeftCorner = tileset.getSubimage(0, tsY, BORDER_WIDTH, BORDER_HEIGHT);
		Image middleBorder = tileset.getSubimage(BORDER_WIDTH + 1, tsY, 1, BORDER_HEIGHT);
		Image middleRightCorner = tileset.getSubimage(BORDER_WIDTH + 3, tsY, BORDER_WIDTH, BORDER_HEIGHT);
		tsY += BORDER_HEIGHT + 1;
		Image bottomLeftBorder = tileset.getSubimage(0, tsY, BORDER_WIDTH, 1);
		Image bottomRightBorder = tileset.getSubimage(BORDER_WIDTH + 3, tsY, BORDER_WIDTH, 1);
		tsY += 2;
		Image bottomLeftCorner = tileset.getSubimage(0, tsY, BORDER_WIDTH, BOTTOM_HEIGHT);
		Image bottomBorder = tileset.getSubimage(BORDER_WIDTH + 1, tsY, 1, BOTTOM_HEIGHT);
		Image bottomRightCorner = tileset.getSubimage(BORDER_WIDTH + 3, tsY, BORDER_WIDTH, BOTTOM_HEIGHT);

		BufferedImage img = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
		Graphics g = img.getGraphics();

		int rightBorderX = WIDTH - BORDER_WIDTH;
		int middleBorderY = BORDER_HEIGHT + TOP_BOX_HEIGHT;
		int bottomBorderY = HEIGHT - BOTTOM_HEIGHT;

		// Draw all the corners
		g.drawImage(topLeftCorner, 0, 0, this);
		g.drawImage(topRightCorner, rightBorderX, 0, this);
		g.drawImage(middleLeftCorner, 0, middleBorderY, this);
		g.drawImage(middleRightCorner, rightBorderX, middleBorderY, this);
		g.drawImage(bottomLeftCorner, 0, bottomBorderY, this);
		g.drawImage(bottomRightCorner, rightBorderX, bottomBorderY, this);

		// Draw all the horizontal borders
		for (int x = BORDER_WIDTH; x < rightBorderX; x++) {
			g.drawImage(topBorder, x, 0, this);
			g.drawImage(middleBorder, x, middleBorderY, this);
			g.drawImage(bottomBorder, x, bottomBorderY, this);
		}
		// Draw the top set of vertical borders
		for (int y = BORDER_HEIGHT; y < middleBorderY; y++) {
			g.drawImage(topLeftBorder, 0, y, this);
			g.drawImage(topRightBorder, rightBorderX, y, this);
		}
		// Draw the bottom set of vertical borders
		for (int y = middleBorderY + BORDER_HEIGHT; y < bottomBorderY; y++) {
			g.drawImage(bottomLeftBorder, 0, y, this);
			g.drawImage(bottomRightBorder, rightBorderX, y, this);
		}

		// Get the background color out of the tileset and fill the box with it
		g.setColor(new Color(tileset.getRGB(TS_COLOR_X, TS_MISC_Y)));
		g.fillRect(BORDER_WIDTH, BORDER_HEIGHT, WIDTH - 2 * BORDER_WIDTH, TOP_BOX_HEIGHT);

		g.dispose();
		return img;
	}

	// Helper for placing components in the null layout at specific coordinates
	private void placeComponent(JComponent c, int x, int y, Insets insets) {
		add(c);
		Dimension size = c.getPreferredSize();
		c.setBounds(x + insets.left, y + insets.top, size.width, size.height);
	}

	private void stopGame() {
		TIMER.stop();
		gameEnded = true;
		for (Tile[] row : BOARD)
			for (Tile tile : row)
				tile.gameEnd();
	}

	// Override the paintComponent method in order to add the background image
	@Override
	public void paintComponent(Graphics g) {
		g.drawImage(BACKGROUND_IMAGE, 0, 0, this);
	}
}