/*十行九列棋譜
 * 			    黑
 * 1   2   3   4   5  6   7   8   9
 * 車 馬 象 士 將 士 象 馬 車
 * 空 空 空 空 空 空 空 空 空
 * 空 炮 空 空 空 空 空 炮 空
 * 卒 空 卒 空 卒 空 卒 空 卒
 * 空 空 空 空 空 空 空 空 空
 * －－－－楚河     漢界－－－－－
 * 空 空 空 空 空 空 空 空 空
 * 兵 空 兵 空 兵 空 兵 空 兵
 * 空 炮 空 空 空 空 空 炮 空
 * 空 空 空 空 空 空 空 空 空
 * 車 馬 相 士 帥 士 相 馬 車
 * 
 * 九 八 七 六 五 四 三 二 一
 * 				紅
 * 
 * 一開始不考慮顏色，只考慮兩種棋子
 */
package com.catking.chess;

import com.catking.Utility.*;
import com.catking.Manager.*;

import java.util.*;
import org.eclipse.swt.graphics.GC;


abstract public class Chess implements ChessKind{
	
	
	protected int x;
	protected int y;
	protected int color;
	protected Stack<ChessState> pre_chesses_stack;
	protected char name;
	

	public Chess(int color){

		this.color = color;
		this.pre_chesses_stack = new Stack<ChessState>();
	}
	////////////
	public void paint(){
		
		ChessPane.canvas.paint(x, y, name, color == ATTACK_UP);
	}
	public void showCursor(){
		
		if(BoardStateManager.isGaming()){
			
			if(ChessPane.pre_player != color )
				ChessPane.canvas.showSelectedCursor();
			else
				ChessPane.canvas.resetCursor();
		}
	}
	public boolean showSelectedEffect(){
		boolean isOK = false;
		if(ChessPane.pre_player != color){
			ChessPane.canvas.showSelectedEffect(x, y, name, color == ATTACK_UP);
			isOK = true;
		}
		return isOK;
	}
	/////////////
	
	public int setPos(int x, int y, boolean alternative) {

		if(alternative && ChessPane.pre_player == color)			//已經動過棋子了！！
			return BoardStateManager.CANNOT_PUT_CHESS;

		Set<Position>p = availableSteps();
		boolean isOK = p.contains(new Position(x, y));

		String wavFileName = null;

		if(isOK){
			//更新ChessPane

			if(ChessPane.chesses[x][y].color == KONG)
				wavFileName = "Wav/mov.wav";
			else
				wavFileName = "Wav/eat.wav";
			Utilities.playSound(wavFileName);
			
			//記錄被占領的棋子的信息和原來棋子的位置
			this.pre_chesses_stack.add(
					new ChessState(
							ChessPane.chesses[x][y], 
							this.x, this.y, 
							ChessPane.isJiangJunState[color],
							ChessPane.isJiangJunState[3 - color]));
			//侵占
			ChessPane.chesses[x][y] = this;
			
			Kong kong = new Kong(KONG);
			kong.x = this.x;
			kong.y = this.y;
			ChessPane.chesses[this.x][this.y] = kong;
			
			this.x = x;
			this.y = y;
			
			//標志自己動的棋子
			ChessPane.pre_player = color;
			
			//記錄上一步是不是已經被將了
			boolean isAlreadyJiangJun = ChessPane.isJiangJunState[color];
			
			//檢測并且更新全局被將情況
			ChessPane.checkJiangJunState();

			//檢測自己動完棋子后是不是仍然處于被將狀態，如果被將，就輸掉了比賽
			if(ChessPane.isJiangJunState[color] && isAlreadyJiangJun){
				//輸了
				//語音提示
				//Utilities.delay(2000);
				Utilities.playSound("Wav/endGame.wav");
				ChessPane.canvas.showGameOver(color != ATTACK_UP);
				return BoardStateManager.GAME_OVER;
			}
			//自己失誤將自己的軍，不行的！！
			else if(ChessPane.isJiangJunState[color]){
				
				undo();
				//重新得到棋權
				ChessPane.pre_player = 3 - color;
				return BoardStateManager.CANNOT_PUT_CHESS;
			}
			//記錄雙方最后一步棋
			ChessPane.prePosition[color] = new Position(x, y);
			
			return BoardStateManager.CAN_PUT_CHESS;

		}
		return BoardStateManager.CANNOT_PUT_CHESS;
	}
	/*	首先意識到將軍方法的復雜性
	 * 1.自己動過棋子后，應該檢測包括該棋子在內的所以可以將對方軍的棋子是否已經將對方的軍
	 * 2.檢測動過棋子后，自己將軍的被將情況
	 * 3.更新被將狀態標志（對方和自己）
	 * 
	 * 解決方案，每個棋子只負責自己對老將的威脅
	 * 然后由表盤統一檢查（調用每個可能將軍的棋子）兩個老將的被將狀態
	 */
	public boolean isJiangJun(){

		boolean isOK = false;
		Set<Position>p = availableSteps();
		int index = 3 - color;			//得到對方將軍位置1->2 2->1
		isOK = p.contains(ChessPane.jiangPos[index]);
		//對方被將軍了咯
		if(isOK){
			Utilities.playSound("Wav/jiangjun.wav");
		
			//更新對方被將狀態
			ChessPane.isJiangJunState[index] = true;
		}
		
		return isOK;
	}
	
	public boolean undo(){
		if(this.pre_chesses_stack.isEmpty())
			return false;
		
		
		//得到最近進去的棋子
		ChessState state = this.pre_chesses_stack.pop();
		
		ChessPane.chesses[x][y] = state.chess;
		
		
		x = state.x;
		y = state.y;
		ChessPane.chesses[state.x][state.y] = this;
		
		ChessPane.isJiangJunState[color] = state.myBossSafe;
		ChessPane.isJiangJunState[3 - color] = state.hisBossSafe;
		
		//更新最后一步棋的位置
		ChessPane.prePosition[color] = new Position(x, y);
		return true;
	}

	abstract public void go(); 
	abstract public Set<Position> availableSteps();
	



}