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

/* Generaliserad variant av uppgift 9.4 - med variabelt antal rutor.
*  Obs: ingen speldynamik i denna klassen. Extrauppgift för den intresserade
*  att implementera! */
public class Chess extends JPanel {
    private static final int MIN_SQUARES = 3;
    private static final int STANDARD_SQUARES = 3;
    private static final int STANDARD_SQUARE_SIZE = 100;
    private static final String FONT_FAMILY = Font.SANS_SERIF;
    private static final int FONT_STYLE = Font.PLAIN;
    private static final Color BLACK = Color.BLACK;
    private static final Color WHITE = Color.WHITE;
    private static final Color FOREGROUND = Color.RED;    

    private char[][] spelplan;
    private int squares;

    public Chess() {
        this(STANDARD_SQUARES, STANDARD_SQUARE_SIZE, STANDARD_SQUARE_SIZE);
    }

    public Chess(int squares) {
        this(squares, STANDARD_SQUARE_SIZE, STANDARD_SQUARE_SIZE);
    }

    public Chess(int squares, int squaresizeX, int squaresizeY) {
        if (squares < MIN_SQUARES) {
            throw new IllegalArgumentException("You must have at least 3x3 squares.");
        }
        this.squares = squares;
        spelplan = new char[squares][squares];
        setPreferredSize(new Dimension(squares*squaresizeX,
            squares*squaresizeY));
    }

    public char avläs(int x, int y) {
        int realX = x-1;
        int realY = y-1;
        if (realX < 0 || realY < 0 || realX > squares-1 || realY > squares-1)
            throw new IllegalArgumentException("Allowable: 0 < x <= " + squares
                + ", 0 < y <= " + squares);
        return spelplan[realX][realY];
    }

    // eventuellt lägga till kontroll av tillåten char    
    public void placera(char p, int x, int y) {
        int realX = x-1;
        int realY = y-1;
        if (realX < 0 || realY < 0 || realX > squares-1 || realY > squares-1)
            throw new IllegalArgumentException("Allowable: 0 < x <= " + squares
                + ", 0 < y <= " + squares);
        spelplan[realX][realY] = p;
        repaint();
    }

    public void flytta(int x, int y, int nyX, int nyY) {
        int realX = x-1;
        int realY = y-1;
        int realNyX = nyX-1;
        int realNyY = nyY-1;
        if (realX < 0 || realY < 0 || realX > squares-1 || realY > squares-1
                || realNyX < 0 || realNyY < 0 || realNyX > squares-1 || realNyY > squares-1)
            throw new IllegalArgumentException("Allowable: 0 < x <= " + squares
                + ", 0 < y <= " + squares);
        spelplan[realNyX][realNyY] = spelplan[realX][realY];
        spelplan[realX][realY] = '\0';
        repaint();
    }

    // antagande: för bräda med nxn rutor krävs n pjäser i rad för vinst
    public char vinst() {
        // kolla lodrätta rader
        for (int x=0;x<squares;x++) {
            int y=0;
            for ( ;y<squares-1;y++) {
                if (spelplan[x][y] != spelplan[x][y+1] || spelplan[x][y] == '\0') {
                    break;
                }
            }
            if (y==squares-1) {
                return spelplan[x][y];
            }
        }
        // kolla vågrätta rader
        for (int y=0;y<squares;y++) {
            int x=0;
            for ( ;x<squares-1;x++) {
                if (spelplan[x][y] != spelplan[x+1][y] || spelplan[x][y] == '\0') {
                    break;
                }
            }
            if (x==squares-1) {
                return spelplan[x][y];
            }
        }
        // kolla ena diagonalen
        int i=0;
        for (;i<squares-1;i++) {
            if (spelplan[i][i] != spelplan[i+1][i+1] || spelplan[i][i] == '\0') {
                break;
            }
        }
        if (i==squares-1) {
            return spelplan[i][i];
        }
        // kolla andra diagonalen
        for (i=0;i<squares-1;i++) {
            int iReflekt = squares - 1 - i;
            if (spelplan[i][iReflekt] != spelplan[i+1][iReflekt-1]
                    || spelplan[i][iReflekt] == '\0') {
                break;
            }
        }
        if (i==squares-1) {
            return spelplan[i][squares-1-i];
        }
        return '\0';
    }

    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.setColor(BLACK);
        int width = getWidth() / squares;
        int height = getHeight() / squares;
        g.setFont(new Font(FONT_FAMILY,FONT_STYLE,height));
        for (int x=0;x<squares;x++) {
            for (int y=0;y<squares;y++) {
                g.setColor(g.getColor() == BLACK ? WHITE : BLACK); //skifta färg på pennan
                int startX = x*width;
                int startY = y*height;
                g.fillRect(startX, startY, startX+width, startY+height);
                if (spelplan[x][y] != '\0') {
                    Color oldCol = g.getColor();
                    g.setColor(FOREGROUND);
                    g.drawString(spelplan[x][y] + "", startX, startY+height);
                    g.setColor(oldCol);
                }
            }
        }
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Luffarschack");
        Chess chess = new Chess();
        frame.add(chess, BorderLayout.CENTER);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
        chess.placera('X', 1, 3);
        chess.placera('X', 3, 1);
        chess.placera('X', 1, 2);
        chess.flytta(1,2,1,1);

        // snabbt skrivet test av vinst()... validerar inget utan man måste
        // själv kontrollera att det stämmer
        // mycket 'magic numbers' här (ska man ju hålla sig borta ifrån) men
        // vi vill bara ha fram ett snabbt test så vi har överseende
        Random rnd = new Random();
        for (int i = 3; i<=7; i++) {   //antal rutor
            for (int j=0; j<10; j++) { //antal tester för varje antal rutor
                chess = new Chess(i);
                for (int k=0;k<6*i;k++) {   //slumpa fram några placeringar
                    char c = rnd.nextInt(2)==1 ? 'X' : 'O';
                    chess.placera(c, rnd.nextInt(i)+1, rnd.nextInt(i)+1);
                }
                for (int x=0; x<i; x++) {   // skriv ut spelplanen
                    for (int y=0; y<i; y++) {
                        // notera att spelplan endast är åtkomlig eftersom
                        // vi skrivit testet i samma klass
                        char printChar = chess.spelplan[x][y] == '\0' ?
                                            '-' : chess.spelplan[x][y];
                        System.out.print(printChar + " ");
                    }
                    System.out.println();
                }
                System.out.println("Vinnare: " + chess.vinst());
            }
        }
    }
}