package dao;

import iniset.PropertySet;
import iniset.finals.SetDatas;

import java.awt.Cursor;
import java.awt.GridLayout;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.LinkedList;

import javax.swing.JLabel;
import dao.popinf.PopInf;

import view.CreatWindow;
import vo.ChessPoint;
import vo.CursorsAndImg;
import vo.Enums;
import vo.sounds.Sound;

/**
 * 棋盤類，繼承自JLabel,實現MouseListener接口,是本游戲的核心部分，負責事件處理 判斷
 * 
 * @author B.Lee
 * @version 2008.05.10
 */
public class Battel extends JLabel implements MouseListener {
  public int dirBeginX[];

  public int dirBeginY[];

  public int lineBeginX[];

  public int lineBeginY[];

  public int offsetX[];

  public int offsetY[];

  public int scoreBlack[] = { 0, 10, 50, 500, 10000 };

  public int scoreWhite[] = { 0, 10, 50, 500, 10000 };

  private int i0, j0;

  private PropertySet propertySet = null;

  CreatWindow creatWindow = null;

  /**
   * 用于存放悔棋路徑
   */
  public LinkedList<ChessPoint> path = new LinkedList<ChessPoint>();

  /**
   * 是否已經分出勝負的變量
   */
  boolean end;

  /**
   * 用來實現棋盤的按鈕
   */
  private ChessPoint[][] chPoint = new ChessPoint[15][15];

  private Enums.chessState nowPlayer;

  /**
   * 構造函數
   */
  public Battel(CreatWindow window) {
    this.creatWindow = window;
    this.setIcon(CursorsAndImg.BACK);
    this.setSize(540, 540);
    this.setVisible(true);

    GridLayout gridLayout = new GridLayout();
    gridLayout.setRows(15);
    gridLayout.setColumns(15);
    gridLayout.setHgap(0);
    gridLayout.setVgap(0);
    this.setLayout(gridLayout);

    for (int row = 0; row < 15; row++)
      for (int col = 0; col < 15; col++) {
        chPoint[row][col] = new ChessPoint(Enums.chessState.NONE, new Point(
            row, col));
        chPoint[row][col].addMouseListener(this);
        this.add(chPoint[row][col]);
      }

    dirBeginX = new int[] { 0, 0, 0, 1, 0, 14 };
    dirBeginY = new int[] { 0, 0, 0, 0, 0, 1 };
    lineBeginX = new int[] { 0, 1, 0, 1, 1, 0 };
    lineBeginY = new int[] { 1, 0, 1, 0, 0, 1 };
    offsetX = new int[] { 1, 0, 1, 1, -1, -1 };
    offsetY = new int[] { 0, 1, 1, 1, 1, 1 };

    propertySet = PropertySet.getPropertySet();
    // 初始化當前玩家
    nowPlayer = propertySet.getFirst() == SetDatas.BLACK_FIRST ? Enums.chessState.BLACK
        : Enums.chessState.WHITE;
  }

  // 以下為該類的其它非設置獲取參數的函數

  /**
   * 電腦選擇一個點下棋
   */
  private void chosePoint() {
    resetScore();
    evaluate();
    getMax();
  }

  /**
   * 重新設置各點的分值
   */
  private void resetScore() { // 重設分值
    for (int row = 0; row < 15; row++)
      for (int col = 0; col < 15; col++) {
        if (getchessPoint(new Point(row, col)).getState() == Enums.chessState.NONE) {
          getchessPoint(new Point(row, col)).setScore(0);
        }
      }
  }

  /**
   * 判斷并為各點打分
   */
  private void evaluate() {
    for (int k = 0; k < 6; k++) {
      int lineX = this.dirBeginX[k];
      int lineY = this.dirBeginY[k];
      line: for (; valid(lineX, lineY); lineX += lineBeginX[k], lineY += lineBeginY[k]) {
        int x = lineX;
        int y = lineY;
        point: for (; valid(x, y); x += this.offsetX[k], y += this.offsetY[k]) {
          int m = 0;
          Enums.chessState state = Enums.chessState.NONE;
          for (int l = 0; l < 5; l++) {
            int xx = x + l * this.offsetX[k];
            int yy = y + l * this.offsetY[k];
            if (!valid(xx, yy)) {
              continue line;
            }
            if (state == Enums.chessState.NONE) {
              if (getchessPoint(new Point(xx, yy)).getState() != Enums.chessState.NONE) {
                m = 1;
                state = getchessPoint(new Point(xx, yy)).getState();
              }
            } else {
              if (getchessPoint(new Point(xx, yy)).getState() == Enums.chessState.NONE)
                continue;
              if (state != getchessPoint(new Point(xx, yy)).getState()) {
                continue point;
              }
              m++;
            }
          }
          // score
          if (m == 0)// 當前點分數為零
            continue;
          if (m == 5) {
            end = true;
            if (state == Enums.chessState.BLACK) {
              // 玩家贏
              if(propertySet.getSound() == SetDatas.SOUND_ON) {
                Sound.getSound().play(Sound.WIN);//播放玩家贏時的音效
              }
              PopInf.informBlackWin(this);
              // 重新布置棋盤
              for (int row = 0; row < 15; row++)
                for (int col = 0; col < 15; col++) {
                  getchessPoint(new Point(row, col)).setState(
                      Enums.chessState.BLACK);
                }
              return;
            } else {
              //玩家輸
              if(propertySet.getSound() == SetDatas.SOUND_ON) {
                if(propertySet.getModel() == SetDatas.PEOPLE_VS_COMPUTER){//如果人機對戰則此時人輸
                  Sound.getSound().play(Sound.LOSS);//播放玩家輸時的音效
                } else { //播放贏的音效
                  Sound.getSound().play(Sound.WIN);
                }
              }
              PopInf.informWhiteWin(this);
              for (int row = 0; row < 15; row++)
                for (int col = 0; col < 15; col++) {
                  getchessPoint(new Point(row, col)).setState(
                      Enums.chessState.BLACK);
                }
              return;
            }
          }
          int sc = state == Enums.chessState.BLACK ? this.scoreBlack[m]
              : this.scoreWhite[m];
          for (int l = 0; l < 5; l++) {
            int xx = x + l * this.offsetX[k];
            int yy = y + l * this.offsetY[k];
            if (getchessPoint(new Point(xx, yy)).getState() == Enums.chessState.NONE) {
              getchessPoint(new Point(xx, yy)).setScore(
                  getchessPoint(new Point(xx, yy)).getScore() + sc);
            }
          }
        }
      }
    }
  }

  private void getMax() {
    float max = 0;
    i0 = j0 = -1;
    for (int row = 0; row < 15; row++) {
      for (int col = 0; col < 15; col++) {
        if (getchessPoint(new Point(row, col)).getState() == Enums.chessState.NONE) {
          if (max < getchessPoint(new Point(row, col)).getScore()) {
            max = getchessPoint(new Point(row, col)).getScore();
            i0 = row;
            j0 = col;
          }
        }
      }
    }
    if (i0 == -1 || j0 == -1) {
      i0 = j0 = 15 / 2;
    }
  }

  public boolean valid(int i, int j) {// 判斷點是否在棋盤里
    return i >= 0 && i < 15 && j >= 0 && j < 15;
  }

  /**
   * 
   * @return 當前棋盤
   */
  public Battel getBattel() {// 獲取當前棋盤
    return this;
  }

  public Enums.chessState getNowPlayer() {
    return nowPlayer;
  }

  public void setNowPlayer(Enums.chessState nowPlayer) {
    this.nowPlayer = nowPlayer;
  }

  /**
   * 獲取當前棋盤按鈕數組
   * 
   * @return 當前棋盤按鈕數組
   */
  public ChessPoint[][] getchPoint() {
    return this.chPoint;
  }

  /**
   * 當想要獲取取一顆棋時調用
   * 
   * @param argPoint
   *          該點的坐標
   * @return 所找點的引用
   */
  public ChessPoint getchessPoint(Point argPoint) {// 反回某一個子
    return getchPoint()[argPoint.x][argPoint.y];
  }

  /**
   * 設置當前游戲狀態
   * 
   * @param argEnd
   *          是否已經結束
   */
  public void setEnd(boolean argEnd) {
    end = argEnd;
  }

  public boolean getEnd() {
    return end;
  }

  // 以下加入事件處理
  /**
   * 當鼠標進入到某個棋子上方時調用 如果當前棋子已經下過棋了，則設置鼠標形狀為不可用，否則設置為可用并在棋盤上標示
   */
  public void mouseEntered(MouseEvent e) {
    ChessPoint chessPoint = (ChessPoint) e.getSource();
    if (chessPoint.getState() != Enums.chessState.NONE) {// 如果當前點已經有子了
      setCursor(CursorsAndImg.UN_CHESS_ABLE);
      return;
    } else {
      setCursor(new Cursor(CursorsAndImg.HAND_CURSOR));
      chessPoint.setIcon(CursorsAndImg.PUT_ABLE);
      // System.out.println(chessPoint.getPoint().x + "..."
      // + chessPoint.getPoint().y);// 顯示鼠標位置
    }
  }

  /**
   * 鼠標移出某個棋
   */
  public void mouseExited(MouseEvent e) {
    ChessPoint chessPoint = (ChessPoint) e.getSource();
    if (chessPoint.getState() != Enums.chessState.NONE) {// 如果當前點已經有子了
      setCursor(new Cursor(CursorsAndImg.DEFAULT_CURSOR));
      return;
    } else {
      setCursor(new Cursor(CursorsAndImg.DEFAULT_CURSOR));
      chessPoint.setIcon(CursorsAndImg.NONE_CHESS);
    }
  }

  /**
   * 鼠標在某個位置上單擊了一下
   */
  public void mouseClicked(MouseEvent e) {
    ChessPoint chessPoint = (ChessPoint) e.getSource();
    if (chessPoint.getState() != Enums.chessState.NONE) {// 如果當前點已經有子了
      return;
    } else if (propertySet.getModel() == SetDatas.PEOPLE_VS_COMPUTER) {// 人與電腦下模式
      // if (SoundSet.sound == 1) {
      // new Sound(Sound.PUTCHESS);
      // }
      if(propertySet.getSound() == SetDatas.SOUND_ON) {
        Sound.getSound().play(Sound.PUTCHESS);//播放下棋的音效
      }
      
      chessPoint.setState(Enums.chessState.BLACK); // 下子
      chessPoint.setIcon(CursorsAndImg.BLACK_CHESS);
      creatWindow.addTxtTwo("玩家下棋:     " + "坐標("
          + (chessPoint.getPoint().x + 1) + ",    "
          + (chessPoint.getPoint().y + 1) + ");\n ");
      // 加入到路徑中去
      path.offerLast(getchPoint()[chessPoint.getPoint().x][chessPoint
          .getPoint().y]);
      setCursor(CursorsAndImg.UN_CHESS_ABLE);
      // 此處通知電腦下子
      chosePoint();
      if (end) {// 已分出勝負
        return;
      }
      getchessPoint(new Point(i0, j0)).setState(Enums.chessState.WHITE);// 電腦下棋
      getchessPoint(new Point(i0, j0)).setIcon(CursorsAndImg.WHITE_CHESS);
      // 加入路徑
      path.offerLast(getchPoint()[i0][j0]);
      creatWindow.addTxtTwo("電腦下棋:     " + "坐標(" + (i0 + 1) + ",    "
          + (j0 + 1) + ");\n");
      evaluate();
    } else if (propertySet.getModel() == SetDatas.PEOPLE_VS_PEOPLE) {// 人與人下模式
      if (nowPlayer == Enums.chessState.BLACK) {
        if(propertySet.getSound() == SetDatas.SOUND_ON) {
          Sound.getSound().play(Sound.PUTCHESS);//播放下棋的音效
        }
        
        chessPoint.setState(Enums.chessState.BLACK);
        chessPoint.setIcon(CursorsAndImg.BLACK_CHESS);
        nowPlayer = Enums.chessState.WHITE;
        creatWindow.addTxtTwo("黑方下棋:     " + "坐標("
            + (chessPoint.getPoint().x + 1) + ",    "
            + (chessPoint.getPoint().y + 1) + ");\n");
        // 此處加入聲音等設置
      } else if (nowPlayer == Enums.chessState.WHITE) {
        if(propertySet.getSound() == SetDatas.SOUND_ON) {
          Sound.getSound().play(Sound.PUTCHESS);//播放下棋的音效
        }
        
        chessPoint.setState(Enums.chessState.WHITE);
        chessPoint.setIcon(CursorsAndImg.WHITE_CHESS);
        nowPlayer = Enums.chessState.BLACK;
        creatWindow.addTxtTwo("白方下棋:     " + "坐標("
            + (chessPoint.getPoint().x + 1) + ",    "
            + (chessPoint.getPoint().y + 1) + ");\n");
        // 此處加入聲音等設置
      }
      path.offerLast(getchPoint()[chessPoint.getPoint().x][chessPoint
          .getPoint().y]);
      setCursor(CursorsAndImg.UN_CHESS_ABLE);
      evaluate();
    }
  }

  public void mouseReleased(MouseEvent e) {
    // 空實現
    return;
  }

  public void mousePressed(MouseEvent e) {
    // 空實現
    return;
  }
}