import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class ChessBoard extends JPanel implements MouseListener,MouseMotionListener
{
   public ChessPoint point[][];                                
   public int unitWidth,unitHeight;                            
   int x軸長,y軸長;                                            
   int x,y;                                                    
   boolean move=false;                                         
   public String     紅方顏色="紅色",黑方顏色="黑色";
   ChessPiece 紅車1,紅車2,紅馬1,紅馬2,紅相1,紅相2,紅帥,紅士1,紅士2,
              紅兵1,紅兵2,紅兵3,紅兵4,紅兵5,紅炮1,紅炮2;
   ChessPiece 黑車1,黑車2,黑馬1,黑馬2,黑將,黑士1,黑士2,
              黑卒1,黑卒2,黑卒3,黑卒4,黑卒5,黑象1,黑象2,黑炮1,黑炮2;
   
   int startX,startY;                                         
   int startI,startJ;                                         
   public boolean 紅方走棋=true,黑方走棋=false;               
   Rule rule=null;                                            
   public  MakeChessManual record=null;                        
   public  ChessBoard(int w,int h,int r,int c)
   {
        setLayout(null);
        addMouseListener(this);
        addMouseMotionListener(this);
        Color bc=getBackground();
        unitWidth=w;
        unitHeight=h;
        x軸長=r;
        y軸長=c;
      
        point=new ChessPoint[r+1][c+1]; 
                                        
                                        
        for(int i=1;i<=r;i++)
          {
            for(int j=1;j<=c;j++)
              {
                point[i][j]=new ChessPoint(i*unitWidth,j*unitHeight,false); 
              }
          }

        rule=new Rule(this,point);
        record=new MakeChessManual(this,point) ;  
        
        紅車1=new ChessPiece("車",Color.red,bc,w-4,h-4,this);
        紅車1.set棋子類別(紅方顏色);
        紅車2=new ChessPiece("車",Color.red,bc,w-4,h-4,this);
        紅車2.set棋子類別(紅方顏色);
        紅馬1=new ChessPiece("馬",Color.red,bc,w-4,h-4,this);
        紅馬1.set棋子類別(紅方顏色);
        紅馬2=new ChessPiece("馬",Color.red,bc,w-4,h-4,this);
        紅馬2.set棋子類別(紅方顏色);
        紅炮1=new ChessPiece("炮",Color.red,bc,w-4,h-4,this);
        紅炮1.set棋子類別(紅方顏色);
        紅炮2=new ChessPiece("炮",Color.red,bc,w-4,h-4,this);
        紅炮2.set棋子類別(紅方顏色);
        紅相1=new ChessPiece("相",Color.red,bc,w-4,h-4,this);
        紅相1.set棋子類別(紅方顏色);
        紅相2=new ChessPiece("相",Color.red,bc,w-4,h-4,this);
        紅相2.set棋子類別(紅方顏色);
        紅士1=new ChessPiece("士",Color.red,bc,w-4,h-4,this);
        紅士1.set棋子類別(紅方顏色);
        紅士2=new ChessPiece("士",Color.red,bc,w-4,h-4,this);
        紅士2.set棋子類別(紅方顏色);
        紅帥=new ChessPiece("帥",Color.red,bc,w-4,h-4,this);
        紅帥.set棋子類別(紅方顏色);
        紅兵1=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
        紅兵1.set棋子類別(紅方顏色);
        紅兵2=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
        紅兵2.set棋子類別(紅方顏色);
        紅兵3=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
        紅兵3.set棋子類別(紅方顏色);
        紅兵4=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
        紅兵4.set棋子類別(紅方顏色);
        紅兵5=new ChessPiece("兵",Color.red,bc,w-4,h-4,this);
        紅兵5.set棋子類別(紅方顏色);
         
        黑將=new ChessPiece("將",Color.blue,bc,w-4,h-4,this);
        黑將.set棋子類別(黑方顏色);
        黑士1=new ChessPiece("士",Color.blue,bc,w-4,h-4,this);
        黑士1.set棋子類別(黑方顏色);
        黑士2=new ChessPiece("士",Color.blue,bc,w-4,h-4,this);
        黑士2.set棋子類別(黑方顏色);
        黑車1=new ChessPiece("車",Color.blue,bc,w-4,h-4,this);
        黑車1.set棋子類別(黑方顏色);
        黑車2=new ChessPiece("車",Color.blue,bc,w-4,h-4,this);
        黑車2.set棋子類別(黑方顏色);
        黑炮1=new ChessPiece("炮",Color.blue,bc,w-4,h-4,this);
        黑炮1.set棋子類別(黑方顏色);
        黑炮2=new ChessPiece("炮",Color.blue,bc,w-4,h-4,this);
        黑炮2.set棋子類別(黑方顏色);
        黑象1=new ChessPiece("象",Color.blue,bc,w-4,h-4,this);
        黑象1.set棋子類別(黑方顏色);
        黑象2=new ChessPiece("象",Color.blue,bc,w-4,h-4,this);
        黑象2.set棋子類別(黑方顏色);
        黑馬1=new ChessPiece("馬",Color.blue,bc,w-4,h-4,this);
        黑馬1.set棋子類別(黑方顏色); 
        黑馬2=new ChessPiece("馬",Color.blue,bc,w-4,h-4,this);
        黑馬2.set棋子類別(黑方顏色); 
        黑卒1=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
        黑卒1.set棋子類別(黑方顏色);
        黑卒2=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
        黑卒2.set棋子類別(黑方顏色);
        黑卒3=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
        黑卒3.set棋子類別(黑方顏色);
        黑卒4=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
        黑卒4.set棋子類別(黑方顏色);
        黑卒5=new ChessPiece("卒",Color.blue,bc,w-4,h-4,this);
        黑卒5.set棋子類別(黑方顏色);
        point[1][10].setPiece(紅車1,this);
        point[2][10].setPiece(紅馬1,this);
        point[3][10].setPiece(紅相1,this);
        point[4][10].setPiece(紅士1,this);
        point[5][10].setPiece(紅帥,this);
        point[6][10].setPiece(紅士2,this);
        point[7][10].setPiece(紅相2,this);
        point[8][10].setPiece(紅馬2,this);
        point[9][10].setPiece(紅車2,this);
        point[2][8].setPiece(紅炮1,this);
        point[8][8].setPiece(紅炮2,this);  
        point[1][7].setPiece(紅兵1,this);
        point[3][7].setPiece(紅兵2,this);
        point[5][7].setPiece(紅兵3,this);
        point[7][7].setPiece(紅兵4,this);
        point[9][7].setPiece(紅兵5,this);

        point[1][1].setPiece(黑車1,this);
        point[2][1].setPiece(黑馬1,this);
        point[3][1].setPiece(黑象1,this);
        point[4][1].setPiece(黑士1,this);
        point[5][1].setPiece(黑將,this);
        point[6][1].setPiece(黑士2,this);
        point[7][1].setPiece(黑象2,this);
        point[8][1].setPiece(黑馬2,this);
        point[9][1].setPiece(黑車2,this);
        point[2][3].setPiece(黑炮1,this);
        point[8][3].setPiece(黑炮2,this);
        point[1][4].setPiece(黑卒1,this);
        point[3][4].setPiece(黑卒2,this);
        point[5][4].setPiece(黑卒3,this);
        point[7][4].setPiece(黑卒4,this);
        point[9][4].setPiece(黑卒5,this);
    
    }
  public void paintComponent(Graphics g)
   {
     super.paintComponent(g);
      for(int j=1;j<=y軸長;j++)   
       {
          g.drawLine(point[1][j].x,point[1][j].y,point[x軸長][j].x,point[x軸長][j].y); 
       }
     for(int i=1;i<=x軸長;i++)     
       {
         if(i!=1&&i!=x軸長)
          {
            g.drawLine(point[i][1].x,point[i][1].y,point[i][y軸長-5].x,point[i][y軸長-5].y);
            g.drawLine(point[i][y軸長-4].x,point[i][y軸長-4].y,point[i][y軸長].x,point[i][y軸長].y); 
          }
         else
          {
            g.drawLine(point[i][1].x,point[i][1].y,point[i][y軸長].x,point[i][y軸長].y);
          }
       }
      
       g.drawLine(point[4][1].x,point[4][1].y,point[6][3].x,point[6][3].y);
       g.drawLine(point[6][1].x,point[6][1].y,point[4][3].x,point[4][3].y);
       g.drawLine(point[4][8].x,point[4][8].y,point[6][y軸長].x,point[6][y軸長].y);
       g.drawLine(point[4][y軸長].x,point[4][y軸長].y,point[6][8].x,point[6][8].y);
     
       for(int i=1;i<=x軸長;i++)
       { 
          g.drawString(""+i,i*unitWidth,unitHeight/2);
       }
       int j=1;
      for(char c='A';c<='J';c++)
       { 
          g.drawString(""+c,unitWidth/4,j*unitHeight);
          j++;
       }
         
   } 
  public void mousePressed(MouseEvent e)
  { 
    ChessPiece piece=null;
    Rectangle rect=null;
    if(e.getSource()==this)
        move=false;
    if(move==false)
      if(e.getSource() instanceof ChessPiece)
       {
         piece=(ChessPiece)e.getSource();   
         startX=piece.getBounds().x;        
         startY=piece.getBounds().y;     
         
          rect=piece.getBounds();
          for(int i=1;i<=x軸長;i++)
            {
              for(int j=1;j<=y軸長;j++)
                {
                  int x=point[i][j].getX();
                  int y=point[i][j].getY();
                  if(rect.contains(x,y))
                   {                   
                     startI=i;
                     startJ=j;
                     break;
                   }
                  
                }
            }
       }
  } 
 public void mouseMoved(MouseEvent e)
  { 
  }
 public void mouseDragged(MouseEvent e)
  {
 
    ChessPiece piece=null;
       if(e.getSource() instanceof ChessPiece)
         {
           piece=(ChessPiece)e.getSource();   
           
           move=true; 
           
           e=SwingUtilities.convertMouseEvent(piece,e,this); 
         }
    
       if(e.getSource()==this)
        {
          if(move&&piece!=null)
           {
            x=e.getX(); 
            y=e.getY();
            if(紅方走棋&&((piece.棋子類別()).equals(紅方顏色)))
               {
                 piece.setLocation(x-piece.getWidth()/2,y-piece.getHeight()/2);
               }
            if(黑方走棋&&(piece.棋子類別().equals(黑方顏色)))
               {
                 piece.setLocation(x-piece.getWidth()/2,y-piece.getHeight()/2);
               }
           }
        }
 }
 public void mouseReleased(MouseEvent e)
  { 
    ChessPiece piece=null;
    move=false;
    Rectangle rect=null;
    if(e.getSource() instanceof ChessPiece)
      {
        piece=(ChessPiece)e.getSource();   
        rect=piece.getBounds();
         
        e=SwingUtilities.convertMouseEvent(piece,e,this); 
      }
    if(e.getSource()==this)
     {
        boolean containChessPoint=false;
        int x=0,y=0;
        int m=0,n=0;
        if(piece!=null)
         { 
          for(int i=1;i<=x軸長;i++)
            {
              for(int j=1;j<=y軸長;j++)
                {
                  x=point[i][j].getX();
                  y=point[i][j].getY();
                  if(rect.contains(x,y))
                   { 
                    
                     containChessPoint=true;
                     m=i;
                     n=j;
                     break;
                   }
                  
                }
            }
         }
        if(piece!=null&&containChessPoint)
         {
           Color pieceColor=piece.獲取棋子顏色();
          if(point[m][n].isPiece()) 
            { 
               Color c=(point[m][n].getPiece()).獲取棋子顏色();
               if(pieceColor.getRGB()==c.getRGB())
                   { 
                     piece.setLocation(startX,startY);
                     
                     (point[startI][startJ]).set有棋子(true);
                   }                  
               else
                   { 
                      boolean ok=rule.movePieceRule(piece,startI,startJ, m,n);
                      if(ok)
                       {                 
                            ChessPiece pieceRemoved=point[m][n].getPiece();
                            point[m][n].reMovePiece(pieceRemoved,this);
                            point[m][n].setPiece(piece,this);
                            (point[startI][startJ]).set有棋子(false);
                            record.記錄棋譜(piece,startI,startJ,m,n) ;
                            record.記錄吃掉的棋子(pieceRemoved)   ;      
                             if(piece.棋子類別().equals(紅方顏色))
                                {
                                   紅方走棋=false;
                                   黑方走棋=true;
                                }
                             if(piece.棋子類別().equals(黑方顏色))
                                {
                                   黑方走棋=false;
                                   紅方走棋=true;
                               }
                           validate();
                           repaint();
                       }
                      else    
                       {
                           piece.setLocation(startX,startY);
                           (point[startI][startJ]).set有棋子(true);
                       }
                   }
                 
            }
          else
            {
              
               boolean ok=rule.movePieceRule(piece,startI,startJ, m,n);
               if(ok)
                 {
                    point[m][n].setPiece(piece,this);
                   (point[startI][startJ]).set有棋子(false);
                   record.記錄棋譜(piece,startI,startJ,m,n) ;
                   record.記錄吃掉的棋子("沒吃棋子");        
                     if(piece.棋子類別().equals(紅方顏色))
                       {
                          紅方走棋=false;
                          黑方走棋=true;
                       }
                      if(piece.棋子類別().equals(黑方顏色))
                       {
                         黑方走棋=false;
                         紅方走棋=true;
                       }
                 }
               else     
                 {
                   piece.setLocation(startX,startY);
                   (point[startI][startJ]).set有棋子(true);
                 }
            }
        }
     if(piece!=null&&!containChessPoint)        
       {        
          piece.setLocation(startX,startY);
          (point[startI][startJ]).set有棋子(true);
       }
    }  
  }
 public void mouseEntered(MouseEvent e)
  {
  }
 public void mouseExited(MouseEvent e)
  { 
  }
 public void mouseClicked(MouseEvent e)
  { 
  }
}