package signalFlowGraphInterface;

import java.util.ArrayList;

import javafx.application.Application;
import javafx.geometry.*;
import javafx.scene.Scene;
import javafx.scene.layout.*;
import javafx.scene.paint.Color;
import javafx.stage.Stage;
import signalFlowGraph.AnalyzeSFG;
import javafx.scene.control.*;
import javafx.scene.text.*;
import javafx.scene.shape.*;

public class GUI extends Application {

	private AnalyzeSFG sfg;
	private Stage stage;
	private HBox h = new HBox();
	private VBox v = new VBox();
	private Pane nodesViewer;
    Graph graph = new Graph();
    Model model = graph.getModel();

	public static void main(String[] args) {
		Application.launch(args);
	}

	private boolean oneTimeAdd = false;

	@Override
	public void start(Stage primaryStage) throws Exception {
		stage = primaryStage;
		nodesViewer = new Pane();
		GridPane textBoxes = textBoxes();
		BorderPane container = new BorderPane();

		// container.setGridLinesVisible(true);
		if (!oneTimeAdd) {
			h.getChildren().add(textBoxes);
			oneTimeAdd = true;
		} else {
			nodesViewer = nodesViewer(sfg.getNumberOfNodes());
		}

		container.setTop(h);
		container.setRight(v);
		container.setCenter(nodesViewer);
		Scene scene = new Scene(container, 1200, 700);
		primaryStage.setScene(scene);
		primaryStage.setResizable(false);
		primaryStage.setTitle("Signal Flow Graph Solver");
		primaryStage.show();

	}

	private Pane nodesViewer(int numberOfNodes) {
		Pane nodesViewer = new Pane();
//		Circle circle;
//		StackPane stack;
//		for (int i = 0; i < numberOfNodes; i++) {
//			circle = new Circle();
//			circle.setRadius(100 / numberOfNodes);
//			// circle.setCenterX(200 * i);
//			// circle.setCenterY(200);
//			// circle.setLayoutX(100);
//			circle.setFill(Color.AQUA);
//
//			Text text = new Text((i + 1) + "");
//			text.setBoundsType(TextBoundsType.VISUAL);
//			stack = new StackPane();
//			stack.getChildren().addAll(circle, text);
//			stack.setLayoutY(250);
//			stack.setLayoutX(150 * i);
//			nodesViewer.getChildren().add(stack);
//		}


		return nodesViewer;

	}

	private boolean[][] visited;

	private void initalizeVisited() {
		visited = new boolean[sfg.getMatrix().length][sfg.getMatrix().length];
	}

//	private void printMatrix(boolean[][] mat) {
//		for (int i = 0; i < mat.length; i++)  {
//			for (int j = 0; j < mat.length; j++)
//				System.out.print(mat[i][j]+" ");
//			System.out.println();
//		}
//	}
	private void addLines() {
//		printMatrix(visited);
		double[][] matrix = sfg.getMatrix();
		StackPane stack;
		Arrow arrow;
		double startX, startY, endX, endY;
		for (int i = 1; i < sfg.getNumberOfNodes(); i++) {
			for (int j = 1; j < sfg.getNumberOfNodes(); j++) {
				if (matrix[i - 1][j - 1] != 0 && !visited[i - 1][j - 1]) {
					visited[i - 1][j - 1] = true;
					StackPane s = (StackPane) nodesViewer.getChildren().get(j);
					StackPane s0 = (StackPane) nodesViewer.getChildren().get(j - 1);

					arrow = new Arrow();
					Bounds from = s0.getBoundsInParent();
					Bounds to = s.getBoundsInParent();
					startX = from.getMinX();
					endX = to.getMaxX();
					startY = from.getMaxY();
					endY = to.getMaxY();

					arrow.setStartX(startX);
					arrow.setEndX(endX);
					arrow.setStartY(startY);
					arrow.setEndY(endY);
					System.out.println(startX);
					System.out.println(startY);
					System.out.println(endX);
					System.out.println(endY);
					nodesViewer.getChildren().add(arrow);
				}
			}
		}
	}

	/**
	 *
	 * @return
	 */
	private GridPane textBoxes() {
		GridPane textBoxes = new GridPane();
		textBoxes.setGridLinesVisible(true);
		TextField nodesNumber = new TextField();
		TextField from = new TextField();
		TextField to = new TextField();
		TextField gain = new TextField();
		Button enter = new Button("Enter Values");
		Button enterNodesNumber = new Button("Enter Nodes Number");
		enter.setOnAction(e -> {

			if (nodeNumber(from) == 0) {
				sfg.addFinalNode();
				Label gainLabel = new Label("Gain\n" + sfg.operate());
				gainLabel.setFont(new Font(20));
				v.getChildren().addAll(gainLabel, forwardPath(), loopsPaths());
				try {
					start(stage);
				} catch (Exception e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
			} else
				this.sfg.inputs(nodeNumber(from), nodeNumber(to), gainValue(gain));

			if (sfg.matrixIsCreated())
				addLines();

			from.setText("");
			to.setText("");
			gain.setText("");
			// }
		});

		enterNodesNumber.setOnAction(e -> {
			v = new VBox();
			// oneTimeAdd = false;
			sfg = new AnalyzeSFG();
			sfg.setNumberOfNodes(nodeNumber(nodesNumber));
			try {
				start(stage);
			} catch (Exception e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}

			sfg.createAdjacencyMatrix();
			initalizeVisited();
			addLines();
			nodesNumber.setText("");
			// clear all
		});

		textBoxes.add(from, 0, 0);
		textBoxes.add(to, 0, 1);
		textBoxes.add(gain, 0, 2);
		textBoxes.add(enter, 0, 3);
		textBoxes.add(nodesNumber, 0, 4);
		textBoxes.add(enterNodesNumber, 1, 4);
		return textBoxes;
	}

	/////////////////////////////
	private String concatString(ArrayList<String> arrList, String title) {
		StringBuilder concat = new StringBuilder();
		concat.append(title);
		for (int i = 0; i < arrList.size(); i++)
			concat.append("\n" + arrList.get(i));
		return concat.toString();
	}

	private Label forwardPath() {
		Label label = new Label();
		String forwardPathsString = concatString(sfg.getForwardPath(), "FORWARD PATHS");
		label.setText(forwardPathsString);
		Font font = new Font(20);
		label.setFont(font);
		return label;
	}

	private Label loopsPaths() {
		Label label = new Label();
		String loopsPathsString = new String();

		for (int i = 0; i < sfg.getNonTouchingLoopsPath().size(); i++)
			loopsPathsString += concatString(sfg.getNonTouchingLoopsPath().get(i), ((i + 1) + " Non Touching Loops"));

		label.setText(loopsPathsString);
		Font font = new Font(20);
		label.setFont(font);
		return label;
	}

	private int nodeNumber(TextField field) {
		try {
			return Integer.parseInt(field.getText());
		} catch (NumberFormatException x) {

		}
		return -1;
	}

	private double gainValue(TextField gain) {
		try {
			return Double.parseDouble(gain.getText());
		} catch (NumberFormatException x) {

		}
		return Double.NaN;
	}

}