//////////////////////////////////////////////////////////////
//                      Minesweeper V 0.1                   //
//                                                          //
//  Created by Bruno Caceiro on 05/10/12.                   //
//  Copyright (c) 2012 Bruno Caceiro. All rights reserved.  //
//                                                          //
//  Bruno Caceiro   - 2008107991                            //
//  Leonardo Toledo - 2011168960                            //
//                                                          //
//////////////////////////////////////////////////////////////
import java.util.*;
public class Minesweeper {
    /*****************************************************************
     *  Falta :                                                     **
     *          - Subststituir o -1 default das minas por 'M'       **
     *          - Sistema de pontuação de acordo com o pdf            **
     *          - Melhorar sistema de preencher a matriz(consoante  **
     *            linhas/colunas imprimir moldura !                 **
     ****************************************************************/
    public static void main(String[] args) {

        int [][]matriz;
        matriz=get_biarray();
        matriz=insere_minas(matriz);
        matriz=preenche_matriz(matriz);
        novo_jogo(matriz);
        imprime_tabela_bidimensional(matriz);

    }
            public static void novo_jogo(int[][]a){                 //Melhorar o sistema de pontuacao, para multiplicar por -1 com as minas, só conta as minas  .
                    int n,x,y,minas=0;
                    int pontuacao=0;
                    int linhas = a.length;
                    int colunas = a[0].length;
                    int[] vx = new int [colunas];
                    int[] vy = new int [linhas];
                    Scanner sc=new Scanner(System.in);
                    System.out.print("Numero de posicoes a visitar: ");
                    n=sc.nextInt();
                    for(int i=0;i<n;i++){
                            do{
                                    System.out.print("Insira a coordenada x: ");
                                    x=sc.nextInt();

                            }while(x<0|x>=linhas);
                            do{
                                    System.out.print("Insira a coordenada y: ");
                                    y=sc.nextInt();

                            }while(y<0|y>=colunas);

                            /* Créditos para João Ricardo Lourenço e João Fernandes */
                            Boolean continueAfter = false;
                            for(int j=0;j<i;j++){
                                if (vx[j] == x && vy[j] == y){
                                    System.out.print("\nINSIRa OUTRAS COORDENADAS");
                                    i--;
                                    continueAfter = true;

                                    j = i+1;
                                }
                            }

                            if (continueAfter)
                                continue;

                            System.out.print("Ponto a testar ("+x+","+y+")\n");
                            vx[i] = x;
                            vy[i] = y;

                            /* ---------------------------------------------------- */
                            if(a[x][y]==-1){
                                    minas++;
                            }
                            else{
                                    pontuacao+=a[x][y];
                            }

                    }
                    System.out.println("Acertou em "+minas+" minas e obteve "+pontuacao+" pontos !");
            }
/*
    public static int verifica_casa_matriz(int[][]a,int b){
        int linhas = a.length;
        int colunas = a[0].length;
        int c=0;
        for (int i=0; i<linhas; i++){
            for (int j=0; j<colunas; j++){
                if(a[i][j]==b){
                    c++;
                }
            }
        }
        return c;
    }
*/
    public static int [][]insere_minas(int[][]a){

        int i,pos_x,pos_y;
        int linhas = a.length;
        int colunas = a[0].length;
        int numero_minas=(15*(linhas*colunas))/100;
        System.out.println("Numero de minas="+numero_minas);
        Random gerador= new Random();
        for(i=0;i<numero_minas;i++){
            pos_x=gerador.nextInt(linhas);
            pos_y=gerador.nextInt(colunas);
            if (a[pos_x][pos_y]==-1){           //Melhorar por causa de depois da verificação voltar a gerar uma posição com minas.
                pos_x=gerador.nextInt(linhas);
                pos_y=gerador.nextInt(colunas);
            }
            (a[pos_x][pos_y])=-1;

        }

        return a;
    }
    public static int [][]preenche_matriz(int[][]a){
        int linhas = a.length;
        int colunas = a[0].length;
        /*ESTA MERDA PARECE NÃO ESTAR TOTALMENTE FUNCIONAL AINDA*/
        for (int i=0; i<linhas; i++){
            for (int j=0; j<colunas; j++){
                if(a[i][j]==-1){
                    if((i>=1)&&(a[i-1][j]!=-1)){ // Posição acima
                        a[i-1][j]+=1;
                        if((i+1<linhas)&&(a[i+1][j]!=-1)){ // Posição abaixo
                            a[i+1][j]+=1;
                            if ((j>=1)&&(a[i][j-1]!=-1)){ // Lado -1
                                a[i][j-1]+=1;
                                if ((j+1<colunas)&&(a[i][j+1]!=-1)){ // Lado +1
                                    a[i][j+1]+=1;
                                }
                            }
                        }
                    }
                    /*else if((i+1<linhas)&&(a[i+1][j]!=-1)){ // Posição abaixo
                        a[i+1][j]+=1;
                        System.out.println("AHAHAHA");*/
                }
                    /*else if ((j>=1)&&(a[i][j-1]!=-1)){ // Lado -1
                        a[i][j-1]+=1;
                        System.out.println("AHAHAHA");
                    }*/
                    /*else if ((j+1<colunas)&&(a[i][j+1]!=-1)){ // Lado +1
                        a[i][j+1]+=1;
                        System.out.println("AHAHAHA");
                    }*/
            }
                /*else{                     Não incrementa estas posições
                    a[i][j]+=1;
                } */
        }

        return a;
    }
    //Pede uma matriz de tamanho variavel (x,y) e preenche por default todos os valores com 0.
    public static int [][]get_biarray(){
        Scanner scanner = new Scanner(System.in);
        System.out.print("Numero de linhas: ");
        int linhas = scanner.nextInt();
        System.out.print("Numero de colunas: ");
        int colunas = scanner.nextInt();
        int[][] a = new int[linhas][colunas];
        //System.out.println("\n");
        for (int i=0; i<linhas; i++){
            for (int j=0; j<colunas; j++){
                a[i][j] = 0;
            }
        }
        return a;
    }
    // Imprimir le matriz .  O -1 das minas como ocupa duas casas tem um comportamento diferente .
    public static void imprime_tabela_bidimensional(int[][] a) {
        int linhas = a.length;
        int colunas = a[0].length;
        System.out.println("______________________________________________"); //Fazer isto de acordo com linhas/colunas
        System.out.println("|********* MINESWEEPER V 0.1 ****************|"); // Optimizado para  Matriz 10*10
        System.out.println("|--------------------------------------------|");
        for (int linha=0; linha<linhas; linha++) {
             System.out.print("|*| ");

          for (int coluna=0; coluna<colunas; coluna++) {
            if(a[linha][coluna]==-1){
                System.out.print(a[linha][coluna]+"| ");
            }
            else{
                System.out.print(a[linha][coluna]);
                System.out.print(" | ");
            }

          }
          System.out.print("*|");
          System.out.println();
        }
        System.out.println("|--------------------------------------------|");
  }

}