package minesweeper;

import java.util.Observable;
import java.util.Observer;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.JOptionPane;

public class GameTAlpha extends Observable implements Game {

    private int bombs, cols, rows, timer;
    private Field[][] fields;
    private boolean locked;
    private GameState state = GameState.running;

    @Override
    public void start(int cols, int rows, int bombs) {
        this.bombs = bombs;
        this.cols = cols;
        this.rows = rows;
        if (cols < 1) {
            error("Zu wenig Spalten - mindestens 1");
        }
        if (cols > 1000) {
            error("Zu viele Spalten - maximal 1000");
        }
        if (rows > 1000) {
            error("Zu viele Zeilen - maximal 1000");
        }

        if (rows < 1) {
            error("Zu wenig Zeilen - mindestens 1");
        }
        if (bombs > cols * rows) {
            error("Zu viele Bomben - maximal " + (rows * cols-1));
        }
        if (bombs < 0) {
            error("Minesweeper ohne Bomben? Dein Ernst?");
        }
        timer = 0;
        Timer t = new Timer();
        t.schedule(new TimerTask() {
            @Override
            public void run() {
                addToTimer();
            }
        }, 1000, 1000);

        setRandomMines();
        update();

    }

    void setLost() {
        state = GameState.lost;
        for (int i = 0; i < cols; i++)
            for (int k = 0; k < rows; k++) {
            fields[i][k].uncover();
            }
        locked=true;
    }

    void setWon() {
        state = GameState.won;
        locked=true;
    }

    private void setRandomMines() {

        fields = new Field[cols][rows];
        int btp = bombs;
        // init field
        for (int i = 0; i < cols; i++)
            for (int k = 0; k < rows; k++) {
                fields[i][k] = new Field(false);
            }
        // set random mines
        while (btp > 0) {
            int rx = (int) (Math.random() * cols);
            int ry = (int) (Math.random() * rows);

            if (!fields[rx][ry].isMine()) {
                fields[rx][ry] = new Field(true);
                btp--;
            }
        }
        System.out.println("All Mines could be placed");

    }

    protected void addToTimer() {
        if (!locked) {
            timer++;
            update();
        }

    }

    private void update() {
        setChanged();
        notifyObservers();
    }

    @Override
    public int getBombsLeft() {
        // bombs=bombs
        int allflags = 0;
        for (Field[] f : fields) {
            for (Field ff : f) {
                if (ff.getState() == FieldState.flagged)
                    allflags++;
            }
        }
        return bombs - allflags;
    }

    private void checkVictory() {
        int covered=0;
        for (Field[] f : fields) {
            for (Field ff : f) {
                if (ff.getState()==FieldState.covered||ff.getState()==FieldState.flagged)
                {
                    covered++;
                }
            }
        }
        if (covered==bombs&&state.equals(GameState.running))
        {
            setWon();
            update();
        }
    }

    @Override
    public int getElapsedSeconds() {
        return timer;
    }

    public static void main(String[] args) {

        int cols = Integer.parseInt(JOptionPane.showInputDialog("Breite eingeben!", "20"));
        int rows = Integer.parseInt(JOptionPane.showInputDialog("Höhe eingeben!", "20"));
        int bombs = Integer.parseInt(JOptionPane.showInputDialog("Anzahl Minen eingeben!", "40"));
        // fehlerbehandlung

        GameTAlpha main = new GameTAlpha();

        main.start(cols, rows, bombs);

    }

    private static void error(String message) {
        throw new IllegalArgumentException(message);
    }

    @Override
    public void addStateObserver(Observer observer) {

        addObserver(observer);
    }

    @Override
    public boolean isMine(int col, int row) {
        return fields[col][row].isMine();
    }

    @Override
    public FieldState getFieldState(int col, int row) {
        return fields[col][row].getState();
    }

    @Override
    public void uncover(int col, int row) {
        //TODO: flip adjacent if empty
        if (!locked)
        {
        if (fields[col][row].getState()==FieldState.covered)
        {
        fields[col][row].uncover();
        if (fields[col][row].isMine())
            setLost();

        if (getNeighborMineCount(col, row)==0)
        {
            try{
            uncoverplain(col-1,row-1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col-1,row);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col-1,row+1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col,row-1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col,row+1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col+1,row-1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col+1,row);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col+1,row+1);
            } catch(IndexOutOfBoundsException e)
            {}

        }
        }
        checkVictory();
        update();
        }

    }
    public void uncoverplain(int col, int row) {
        //TODO: flip adjacent if empty
        if (!locked)
        {
        if (fields[col][row].getState()==FieldState.covered)
        {
        fields[col][row].uncover();
        if (fields[col][row].isMine())
            setLost();

        if (getNeighborMineCount(col, row)==0)
        {
            try{
            uncoverplain(col-1,row-1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col-1,row);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col-1,row+1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col,row-1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col,row+1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col+1,row-1);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col+1,row);
            } catch(IndexOutOfBoundsException e)
            {}
            try{
            uncoverplain(col+1,row+1);
            } catch(IndexOutOfBoundsException e)
            {}

        }
        }
        checkVictory();
        }

    }

    @Override
    public void toggleFlag(int col, int row) {
        fields[col][row].toggleFlag();
        update();
    }

    @Override
    public GameState getState() {
        return state;
    }

    @Override
    public int getColCount() {
        return cols;
    }

    @Override
    public int getRowCount() {
        return rows;
    }

    @Override
    public int getNeighborMineCount(int col, int row) throws IndexOutOfBoundsException {
        if (col<0||col>cols||row<0||row>rows)
            throw new IndexOutOfBoundsException("");
        int c=0;
        // xoooooooo
        try {
            if (fields[col - 1][row-1].isMine()) {
                c++;
            }
        } catch (IndexOutOfBoundsException e) {
        }
        // xoooooooo
                try {
                    if (fields[col - 1][row].isMine()) {
                        c++;
                    }
                } catch (IndexOutOfBoundsException e) {
                }
                // xoooooooo
                try {
                    if (fields[col - 1][row+1].isMine()) {
                        c++;
                    }
                } catch (IndexOutOfBoundsException e) {
                }// xoooooooo
                try {
                    if (fields[col][row-1].isMine()) {
                        c++;
                    }
                } catch (IndexOutOfBoundsException e) {
                }// xoooooooo
                try {
                    if (fields[col][row+1].isMine()) {
                        c++;
                    }
                } catch (IndexOutOfBoundsException e) {
                }// xoooooooo
                try {
                    if (fields[col+1][row-1].isMine()) {
                        c++;
                    }
                } catch (IndexOutOfBoundsException e) {
                }// xoooooooo
                try {
                    if (fields[col+1][row].isMine()) {
                        c++;
                    }
                } catch (IndexOutOfBoundsException e) {
                }// xoooooooo
                try {
                    if (fields[col+1][row+1].isMine()) {
                        c++;
                    }
                } catch (IndexOutOfBoundsException e) {
                }
                return c;

    }

}