package five;

/**
 * @author 張聰
 *
 */

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionAdapter;
import java.io.IOException;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class ChessBoard extends JPanel {

	public final static int MARGIN_VALUE = 30;

	public final static int GRID_ROWS = 15;

	public final static int GRID_COLS = 15;

	private final int grid_span = Chess.DIAMETER + 2;

	private Chess[] chessList;

	ChessMain app;

	public ChessBoard(ChessMain appl) {
		chessList = new Chess[(GRID_ROWS + 1) * (GRID_COLS + 1)];
		this.app = appl;

		// 設置鼠標手勢,默認的或者手形的.
		addMouseMotionListener(new MouseMotionAdapter() {
			public void mouseMoved(MouseEvent e) {
				// 網(wǎng)絡沒有連接上 或者 等待對方下棋
				if (!app.isConnected() || !app.isReady()){
					setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
					return;
				}

				Point p = positionToIndex(e.getX(), e.getY());
				if (p.x < 0 || p.x > GRID_ROWS || p.y < 0 || p.y > GRID_COLS) {
					setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
					return;
				}

				if (!exists(p.x, p.y)) {
					setCursor(new Cursor(Cursor.HAND_CURSOR));
				} else {
					setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
				}
			}
		});

		addMouseListener(new MouseAdapter() {
			public void mouseClicked(MouseEvent e) {

				// 網(wǎng)絡沒有連接上
				if (!app.isConnected())
					return;

				// 等待對方下棋
				if (!app.isReady()) {
					return;
				}

				// int x = (e.getX() - MARGIN_VALUE) / grid_span;
				// int y = (e.getY() - MARGIN_VALUE) / grid_span;
				// 轉(zhuǎn)換成網(wǎng)格索引,從0開始
				Point p = positionToIndex(e.getX(), e.getY());
				int x = p.x;
				int y = p.y;

				// 點到了棋盤外
				if (x < 0 || x > GRID_ROWS || y < 0 || y > GRID_COLS)
					return;

				// 該地方已經(jīng)下過棋
				if (exists(x, y))
					return;

				Color c = app.getUserColor();
				Chess chess = new Chess(x, y, Chess.DIAMETER, c);
				try {
					app.sendData(chess);
				} catch (IOException ex) {
					ex.printStackTrace();
					JOptionPane.showMessageDialog(ChessBoard.this, "網(wǎng)絡連接異常!");
				}

			}

		});
		
		// 設置棋盤背景顏色
		setBackground(new Color(99, 135, 113));

	}

	// 清理棋盤
	public void clearBoard() {
		for (int i = 0; i < chessList.length; i++) {
			chessList[i] = null;
		}
		repaint();

	}

	private Point indexToPosition(int x, int y) {
		return new Point(x * grid_span - Chess.DIAMETER / 2 + MARGIN_VALUE, y
				* grid_span + MARGIN_VALUE - Chess.DIAMETER / 2);
	}

	private Point positionToIndex(int x, int y) {
		return new Point((x - MARGIN_VALUE + Chess.DIAMETER / 2) / grid_span,
				(y - MARGIN_VALUE + Chess.DIAMETER / 2) / grid_span);
	}

	// 判斷索引為x, y的棋子是否已經(jīng)存在
	private boolean exists(int x, int y) {
		for (int i = 0; i < chessList.length; i++) {
			if (chessList[i] != null) {
				if (chessList[i].getX() == x && chessList[i].getY() == y)
					return true;
			}
		}

		return false;

	}
	
	public boolean addChess(Chess ch) {
		for (int i = 0; i < chessList.length; i++) {
			if (chessList[i] == null) {
				chessList[i] = ch;
				break;
			}
		}
		repaint();
		
		return isWin(ch);
	}

	//新增加chess對象,判斷是否能贏
	private boolean isWin(Chess chess) {
		int x = chess.getX();
		int y = chess.getY();
		
		int low_x = Math.max(x-4, 0);
		int low_y = Math.max(y-4, 0);
		
		//行有連續(xù)五子
			loop1 :
			for(int i=low_x; i<=x; i++) {
				boolean result = true;
				for(int j=i; j<i+5; j++) {
					if(j>GRID_ROWS)
						continue loop1;
					if(getChess(j, chess.getY(), chess.getColor()) == null) {
						result = false;
					}
				}
				if(result)
					return true;
			}

		//列有連續(xù)五子
			loop2 :
			for(int i=low_y; i<=y; i++) {
				boolean result = true;
				for(int j=i; j<i+5; j++) {
					if(j>GRID_COLS)
						continue loop2;
					if(getChess(chess.getX(), j, chess.getColor()) == null) {
						result = false;
					}
				}
				if(result)
					return true;
		}
		//斜有連續(xù)五子
			loop3 :
		for(int i=low_x, j=low_y; i<=x && j <= y; i++, j++) {
			boolean result = true;
			for(int k=0; k<5; k++) {
				if(i+k > GRID_ROWS || j+k > GRID_COLS)
					continue loop3;
				if(getChess(i+k, j+k, chess.getColor()) == null) {
					result = false;
				}
			}
			if(result)
				return true;
		}

		//斜有連續(xù)五子
			loop4 :
		for(int i=x+4, j=y-4; i>=x && j <= y; i--, j++) {
			boolean result = true;
			for(int k=0; k<5; k++) {
				if(i-k < 0 || j+k > GRID_COLS || i-k >GRID_ROWS || j+k < 0)
					continue loop4;
				if(getChess(i-k, j+k, chess.getColor()) == null) {
					result = false;
				}
			}
			if(result)
				return true;
		}
		
		
		return false;
	}
	
	private Chess getChess(int x, int y, Color c) {
		for(int i=0; i<chessList.length && chessList[i] != null; i++) {
			boolean b = true;
			if( x != -1) //-1則不需要比較,不做限制
				b = b && chessList[i].getX() == x;
			if( y != -1)
				b = b && chessList[i].getY() == y;
			b = b && chessList[i].getColor() == c;
			if(b)
				return chessList[i];
		}
		return null;
	}
	
	// 畫棋盤
	private void drawChessBoard(Graphics g) {
		for (int i = 0; i <= GRID_ROWS; i++) {
			g.setColor(Color.BLACK);
			g.drawLine(MARGIN_VALUE, MARGIN_VALUE + i * grid_span, MARGIN_VALUE
					+ GRID_ROWS * grid_span, MARGIN_VALUE + i * grid_span);
		}
		for (int i = 0; i <= GRID_COLS; i++) {
			g.setColor(Color.BLACK);
			g.drawLine(MARGIN_VALUE + i * grid_span, MARGIN_VALUE, MARGIN_VALUE
					+ i * grid_span, MARGIN_VALUE + GRID_ROWS * grid_span);
		}

	}

	// 畫棋子
	private void drawChessList(Graphics g) {
		int count = 0;
		for (int i = chessList.length-1; i >= 0 ; i--) {
			if (chessList[i] != null) {
				count++;

				Point p = indexToPosition(chessList[i].getX(), chessList[i]
						.getY());
				g.setColor(chessList[i].getColor());
				g.fillOval(p.x, p.y, chessList[i].getDiameter(), chessList[i]
						.getDiameter());
				
				//新下的棋, 帶綠色邊
				if(count == 1 || count == 2) {
					g.setColor(Color.green);
					g.drawOval(p.x, p.y, chessList[i].getDiameter(), chessList[i]
					                                   						.getDiameter());
				}
			}

		}
	}


	public Dimension getPreferredSize() {
		// TODO Auto-generated method stub
		return new Dimension(grid_span * GRID_ROWS + MARGIN_VALUE * 2,
				grid_span * GRID_COLS + MARGIN_VALUE * 2);
	}
	

	public Dimension getMinimumSize() {
		// TODO Auto-generated method stub
		return getPreferredSize();
	}

	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		drawChessBoard(g);
		drawChessList(g);
	}

}