import java.io.

BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Random;
import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.Labeled;
import javafx.scene.image.Image;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import javafx.scene.input.MouseButton;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.StackPane;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.scene.paint.Paint;
import javafx.scene.shape.Rectangle;
import javafx.scene.shape.Shape;
import javafx.scene.text.Font;
import javafx.stage.Stage;

/**
* @author Marlon Alexander Estupian Galindo Cod.1610010802
* @author Edward Fabian Baron Gutierrez Cod.1610010854
* @author Brayan Felipe Barragan Nuez Cod.1610011115
*
*/
public class Sudoku extends Application {

/*Se crea una matriz de caracteres y los colores que tendra el tablero*/

char [][] matriz = new char[9][9];

Paint a1 = Color.BEIGE;
Paint a2 = Color.rgb(141, 219, 229);
Paint a3 = Color.rgb(23, 85, 218);
Paint a4 = Color.rgb(242, 85, 85);

/* Se crea el Gridpane en el cual estaran el tablero y los botones del juego.

* Tambien un Borderpane, el cual tendra un mensaje, puede ser de que se esta
jugando o que ya finalizo.
* Un tablero de la clase Tablero.
* Una variable booleana la cual indicara si se a finalizado el juego o no.
* Una matriz de booleanos, la cual tentra los numeros que estaran fijos en
el tablero de juego.
* Y una matriz de StackPane, en la que en cada casilla estaran un rectangulo
y una etiqueta respectivamente.*/

BorderPane menu;
GridPane tablero;
Tablero t;
 boolean finalized = false;
boolean [][] bMatriz = new boolean[9][9];
StackPane [][] pane = new StackPane[9][9];

/*Matriz de caracteres, la cual cada caracter sera un color*/

char [][] color = new char[][] {

{'g','g','g','b','b','b','g','g','g'},
{'g','g','g','b','b','b','g','g','g'},
{'g','g','g','b','b','b','g','g','g'},
{'b','b','b','g','g','g','b','b','b'},
{'b','b','b','g','g','g','b','b','b'},
{'b','b','b','g','g','g','b','b','b'},
{'g','g','g','b','b','b','g','g','g'},
{'g','g','g','b','b','b','g','g','g'},
{'g','g','g','b','b','b','g','g','g'}
};;

/*Retorna el color de una casilla (i,j) de la Matriz Color*/

public Paint relleno(int i, int j) {
if (color[i][j] == 'g')
return a1;
else
return a2;
}

class Tablero {

/* Se genera un numero aleatorio en el rango de [1,24]

* para asi elegir con que tablero se va a jugar,
* ya que se tienen almacenados 24 tableros.
* */

String s = "" + (1 + new Random().nextInt(24));

File t = new File("Tableros/T" +s+ ".txt");
BufferedReader in;
public Tablero (boolean o, int i) throws IOException {
in = new BufferedReader(new FileReader(t));
formar(o, i);
}

int r = 0;
int y = 1;

/* Se crea la matriz del sudoku usando Rectangulos de 98px * 98px.

* Dentro de cada rectangulo habra una etiqueta la cual
* representara el numero o el espacio vacio de la casilla
* del sudoku.*/

private void formar (boolean o, int l) throws IOException {

generateLevel(o, l);
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
Rectangle a = new Rectangle(68, 68);
a.setFill(relleno(i,j));
Label b = new Label(bMatriz[i][j] ? "" + matriz[i]
[j]: "");
b.setFont(new Font(35));
if (bMatriz[i][j])
 b.setTextFill(a3);
pane[i][j] = new StackPane();
pane[i][j].setStyle("-fx-border-color: black");

/* Se agrega el rectangulo y la etiqueta al

StackPane.
* a = rectangulo
* b = etiqueta
* Y se agrega a la matriz de StackPane(s)*/
pane[i][j].getChildren().addAll(a, b);
}}
}

/* Genera tableros de juego de 3 diferentes niveles

* 1. Facil
* 2. Medio
* 3. Dificil*/

private void generateLevel (boolean o, int level) throws IOException {

if (o) {
int bound = 0;
if (level == 1) bound = 40;
else if (level == 2) bound = 30;
else bound = 20;

Random z = new Random(System.currentTimeMillis());

for (int i = 0; i < matriz.length; i++)

matriz[i] = in.readLine().toCharArray();
for (int i = bound + z.nextInt(3); i > 0; i--){
int k = z.nextInt(9);
int l = z.nextInt(9);
bMatriz[k][l] = true;
}
}
}

/*Retorna un StackPane de la Matriz de StackPane(s) en la posicion

(i,j)*/
public StackPane getNode(int i, int j) {
return pane[i][j];
}
}

@Override
public void start (Stage primaryStage) throws Exception {
menu = new BorderPane();
tablero = new GridPane();
t = new Tablero (true, 1 + new Random().nextInt(3));
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
tablero.add(t.getNode(i,j), j, i);
}
}
tablero.setOnKeyReleased(new EventHandler<KeyEvent>() {

/*Evento: Si la tecla presionada es 'R' el juego se reinica.*/

@Override
public void handle(KeyEvent event) {
 KeyCode code = event.getCode();
if (code.equals(KeyCode.R)){
reiniciar(tablero, menu, t);
}
}
});
tablero.setOnMousePressed(new EventHandler<MouseEvent>() {

@Override
public void handle(MouseEvent event) {
System.out.println(event.getSceneX() + " " +
event.getSceneY());
int i = ((int)event.getSceneX()/70);
int j = ((int)event.getSceneY()/70);

/* Si el juego no a finalizado, se le permitira al jugador

poder cambiar los numeros y colores de las casillas
* que son modificables, de lo contraio, si el juego a
finalizado, se le notificara al jugador por medio de un mensaje en un
* BorderPane y desactivando la opcion de modificar las
casillas.*/

if (!finalized) {
if (i < 9 && j < 9) {
StackPane node = t.getNode(j, i);
MouseButton s = event.getButton();
if (s == MouseButton.PRIMARY)
if (!bMatriz[j][i])
((Labeled)
node.getChildren().get(1)).setText(change(((Labeled)
node.getChildren().get(1)).getText()));
if (!isValid(j, i, t))
if (!bMatriz[j][i])
((Shape)
node.getChildren().get(0)).setFill(a4);
else
((Shape)
node.getChildren().get(0)).setFill(selectColor(j,i));
else
((Shape)
node.getChildren().get(0)).setFill(selectColor(j,i));
}
finalized = isFinalized();
}

/*Retorna el color de la casilla (i,j) de la Matriz de Color.*/

private Paint selectColor (int j, int i) {
return relleno(j, i);
}

/* Retorna falso en caso de que la casilla en la Posicion (i,j)

* este repetida en: la fila, la columna o en la submatriz de 9*9
del tablero.
* De lo contrario retorna true diciendo que la posicion (i,j) es
valida.*/
private boolean isValid(int i, int j, Tablero t) {
 String s = ((Labeled)t.getNode(i,
j).getChildren().get(1)).getText();
for (int k = 0; k < 9; k++) {
if (k != i){
String r = ((Labeled)t.getNode(k,
j).getChildren().get(1)).getText();
if (r.equals(s) && !r.equals(""))
return false;
}
}

for (int k = 0; k < 9; k++) {

if (k != j){
String r = ((Labeled)t.getNode(i,
k).getChildren().get(1)).getText();
if (r.equals(s) && !r.equals(""))
return false;
}
}
int q = (i/3)*3 + 3;
int w = (j/3)*3 + 3;
for (int k = i/3 * 3; k < q; k++) {
for (int l = j/3 * 3; l < w; l++) {
if(k != i && l != j){
String r = ((Labeled)t.getNode(k,
l).getChildren().get(1)).getText();
if (r.equals(s) && !r.equals(""))
return false;
}
}
}

return true;
}

});

/*Visibilidad de las lineas de division del GridPane*/

tablero.setGridLinesVisible(true);

/*Posicion del BorderPane en el juego*/

menu.setCenter(tablero);

/*Texto que tendra el BorderPane mientras se este jugando.*/

menu.setBottom(new Label("Playing..."));

/*Caja Vertical en la cual estaran las etiquetas y botones*/

VBox box = new VBox(50);
box.setPadding(new Insets(100,100,10,150));

/*Boton de reiniciar el juego*/

Button restart = new Button("Restart Game");
restart.setScaleX(2);
restart.setScaleY(2);
VBox.setMargin(restart, new Insets(0,20,0,0));
restart.setOnAction(
new EventHandler<ActionEvent>() {
@Override
 public void handle(final ActionEvent e) {
reiniciar(tablero, menu, t);
}
});
box.getChildren().add(restart);

/*Etiqueta de Nuevo Juego*/

Label level = new Label("New Game");
level.setScaleX(2);
level.setScaleY(2);
level.setTranslateY(100);
box.getChildren().add(level);

/*Boton de Nuevo juego Nivel Facil*/

Button easy= new Button("Easy");
easy.setScaleX(2);
easy.setScaleY(2);
easy.setTranslateY(150);
easy.setStyle("-fx-background-color: lightgreen");
easy.setOnAction(new EventHandler<ActionEvent>() {

@Override
public void handle(ActionEvent event) {
tablero.getChildren().clear();
finalized = false;
bMatriz = new boolean[9][9];
pane = new StackPane[9][9];
try {
t = new Tablero(true, 1);
} catch (IOException e) {
e.printStackTrace();
}

for (int i = 0; i < 9; i++) {

for (int j = 0; j < 9; j++) {
tablero.add(t.getNode(i,j), j, i);
}
}
tablero.requestFocus();
}
});
box.getChildren().add(easy);

/*Boton de Nuevo juego nivel Medio*/

Button medium = new Button("Medium");
medium.setScaleX(2);
medium.setScaleY(2);
medium.setTranslateY(160);
medium.setStyle("-fx-background-color: yellow");
medium.setOnAction(new EventHandler<ActionEvent>() {

@Override
public void handle(ActionEvent event) {
tablero.getChildren().clear();
finalized = false;
bMatriz = new boolean[9][9];
pane = new StackPane[9][9];
try {
t = new Tablero(true, 2);
 } catch (IOException e) {
e.printStackTrace();
}

for (int i = 0; i < 9; i++) {

for (int j = 0; j < 9; j++) {
tablero.add(t.getNode(i,j), j, i);
}
}
tablero.requestFocus();
}
});
box.getChildren().add(medium);

/*Boton de Nuevo juego nivel Dificil*/

Button hard = new Button("Hard");
hard.setScaleX(2);
hard.setScaleY(2);
hard.setTranslateY(170);
hard.setStyle("-fx-background-color: red");
hard.setOnAction(new EventHandler<ActionEvent>() {

@Override
public void handle(ActionEvent event) {
tablero.getChildren().clear();
finalized = false;
bMatriz = new boolean[9][9];
pane = new StackPane[9][9];
try {
t = new Tablero(true, 3);
} catch (IOException e) {
e.printStackTrace();
}

for (int i = 0; i < 9; i++) {

for (int j = 0; j < 9; j++) {
tablero.add(t.getNode(i,j), j, i);
}
}
tablero.requestFocus();
}
});
box.getChildren().add(hard);
menu.setRight(box);

/*Escena*/
Scene scene = new Scene(menu);
primaryStage.setScene(scene);
primaryStage.setTitle("Sudoku");
primaryStage.setResizable(false);
primaryStage.getIcons().add(new Image("file:Iconos/Icon.png"));
primaryStage.show();
tablero.requestFocus();
}

/*Reinicia el juego con el tablero generado en una partida.*/

protected void reiniciar(GridPane tablero, BorderPane menu, Tablero t) {
tablero.getChildren().clear();
for (int i = 0; i < 9; i++) {
 for (int j = 0; j < 9; j++) {
Rectangle a = new Rectangle(68, 68);
a.setFill(relleno(i,j));
Label b = new Label(bMatriz[i][j]? "" + matriz[i][j]: "");
b.setFont(new Font(35));
if (bMatriz[i][j])
b.setTextFill(a3);
pane[i][j].getChildren().clear();
pane[i][j].setStyle("-fx-border-color: black");
pane[i][j].getChildren().addAll(a, b);
}
finalized = false;
menu.setBottom(new Label("Playing..."));
}
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
tablero.add(t.getNode(i,j), j, i);
}}
tablero.requestFocus();
}

/*Cambia del Texto Original a "You won!" si se a completado el sudoku

correctamente.*/
protected void finalized(BorderPane menu) {
menu.setBottom(new Label("You Won!"));
}

/*Retorna falso si el tablero aun no a sido completado, de lo contrario

retorna true.*/
protected boolean isFinalized() {
for (int i = 0; i < 9 ; i++) {
for (int j = 0; j < 9; j++) {
String s = ((Labeled) pane[i]
[j].getChildren().get(1)).getText();

if (!s.equals(""+ matriz[i][j]))
return false;
}}
finalized(menu);
win();
return true;
}

private void win() {

for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
((Shape) pane[i]
[j].getChildren().get(0)).setFill(Color.LIGHTGREEN);
}

/* Cambia el numero de la etiqueta de una casilla.

* De 1 cambia los numeros hasta llegar a 9.
* De 9 pasa a cadena vacia ("").
* De cadena vacia pasa a 1.
* */
 public String change (String text) {
if (text.equals("")) return "1";
if (text.equals("9")) return "";
return "" + (Integer.parseInt(text) + 1);
}

/*-----------------------------------------*/
public static void main(String[]args) {
launch(args);
}
}