import java.util.Random;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowData;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Spinner;

public class GUI implements Runnable {
	
	// Variablen für Fenstergrösse, Gruppen und Buttongrösse festlegen
	private int windowSizeX		= 800;
	private int windowSizeY		= 600;
	private int windowMinSizeX	= 600;
	private int windowMinSizeY	= 565;
	private int buttonSizeY		= 28;
	private int labelSizeY		= 25;
	private int radioGroupSizeY = 27;
	
	private Shell shell;

	private Display display;

	private Drawer currentDrawer;

	private Group messGroup;

	private Canvas dc;

	// zum Messen der Zeit:
	private Clock uhr;

	// unsere Sortierklasse, enthaelt die Sortierfunktionen:
	private Sort sort;

	// das Array, auf dem wir sortieren:
	private int[] values;

	private Button startSort;

	private Button messen;

	private Button zeichnen;

	private Label bubbleErgebnis;

	private Label selectionErgebnis;

	private Label insertionErgebnis;

	private Label mergeErgebnis;

	private Label heapErgebnis;

	private Label quickErgebnis;

	private Spinner spinner;

	private Combo vorsortierung;

	private Combo sortCombo;

	private Combo diagCombo;

	private GraphDrawer gDrawer;

	private BarDrawer bDrawer;

	private GridData dcLayout;

	
	/*****************************************************
	 * Bedienelemente erstellen (NO Click/Change-Handling)
	 * Position: BEGINN
	 */
	
	// GUI starten	
	public GUI() {
		sort = new Sort(this);

		uhr = new Clock();

		display = new Display();
		shell = new Shell(display);
		shell.setSize(windowSizeX, windowSizeY);
		shell.setText("Sortieralgorithmen");
		shell.setMinimumSize(windowMinSizeX,windowMinSizeY);
		
		//Groesse des Bedienfeldes
		int gridSizeX = (int)(shell.getSize().x/5);
		int gridSizeY = (int)(shell.getSize().y*0.9);
		
		// Das Hauptlayout erstellen
		GridLayout gridLayout = new GridLayout();
		gridLayout.numColumns = 2;
		shell.setLayout(gridLayout);

		// Die Zeichenflaeche erstellen
		dcLayout = new GridData();
		dcLayout.grabExcessHorizontalSpace = true;
		dcLayout.grabExcessVerticalSpace = true;
		dcLayout.horizontalAlignment = SWT.FILL;
		dcLayout.verticalAlignment = SWT.FILL;

		dc = new Canvas(shell, SWT.NONE);
		dc.setBackground(new Color(display, 255, 255, 255));

		// Die beiden Drawer erstellen
		gDrawer = new GraphDrawer(dc);
		bDrawer = new BarDrawer(dc);

		// Momentanen Drawer festlegen
		currentDrawer = gDrawer;

		// Auf Zeichnung warten
		dc.addPaintListener(gDrawer);
		dc.setLayoutData(dcLayout);

		// Das Bedienfeld auf der rechten Seite
		GridData controlLayout = new GridData(gridSizeX, gridSizeY);
		Composite control = new Composite(shell, SWT.BORDER);
		control.setLayoutData(controlLayout);
		RowLayout cLayout = new RowLayout();
		cLayout.type = SWT.VERTICAL;
		control.setLayout(cLayout);

		// Label: Arraygroesse
		Label sizeLabel = new Label(control, SWT.NONE);
		sizeLabel.setText("Arraygroesse:");

		// Spinner: Rollfeld für Arraygrössenauswahl
		spinner = new Spinner(control, SWT.BORDER);
		spinner.setMinimum(1);
		spinner.setMaximum(41000000);
		spinner.setSelection(1000);
		spinner.setIncrement(1);
		spinner.setPageIncrement(100);

		// Label: Vorsortierung
		Label vorLabel = new Label(control, SWT.None);
		vorLabel.setText("Vorsortierung:");

		// DropDown-Menü: Vorsortierung
		vorsortierung = new Combo(control, SWT.READ_ONLY);
		vorsortierung.setItems(new String[] { "zufaellig", "sortiert",
				"umgekehrt sortiert", "gauss'sche Kurve" });
		vorsortierung.select(0);
		vorsortierung.setLayoutData(new RowData((int)(gridSizeX-10), labelSizeY));

		// Label: Sortierverfahren
		Label sortLabel = new Label(control, SWT.NONE);
		sortLabel.setText("Sortierverfahren:");

		// DropDown-Menü: Sortierverfahren
		sortCombo = new Combo(control, SWT.READ_ONLY);
		sortCombo.setItems(new String[] { "BubbleSort", "SelectionSort",
				"InsertionSort", "MergeSort" , "QuickSort"});
		sortCombo.select(0);
		sortCombo.setLayoutData(new RowData((int)(gridSizeX-10), buttonSizeY));

		// Radio-Buttons: zeichnen / messen
		Group radioGroup = new Group(control, SWT.None);
		GridLayout radioLayout = new GridLayout();
		radioLayout.numColumns = 1;
		radioGroup.setLayout(radioLayout);
		radioGroup.setLayoutData(new RowData((int)(gridSizeX-15), (2*radioGroupSizeY)));

		// Zeichnen-RadioButton
		zeichnen = new Button(radioGroup, SWT.RADIO);
		zeichnen.setText("zeichnen");
		zeichnen.setSelection(true);

		// Messen-RadioButton
		messen = new Button(radioGroup, SWT.RADIO);
		messen.setText("messen");
		
		// Label: Darstellung
		Label diagLabel = new Label(control, SWT.NONE);
		diagLabel.setText("Darstellung:");

		// DropDown-Menü: Darstellung
		diagCombo = new Combo(control, SWT.READ_ONLY);
		diagCombo.setItems(new String[] { "Punkte", "Balkendiagramm" });
		diagCombo.select(0);
		diagCombo.setLayoutData(new RowData((int)(gridSizeX-10), buttonSizeY));
	
		// Layout für die Buttons setzen
		RowLayout groupLayout = new RowLayout();
		Composite buttonGroup = new Composite(control, SWT.NONE);
		groupLayout.type = SWT.VERTICAL;
		buttonGroup.setLayout(groupLayout);

		// Button: Neues Array
		Button createArray = new Button(buttonGroup, SWT.PUSH);
		createArray.setText("Neues Array");
		createArray.setLayoutData(new RowData((int)(gridSizeX-15), buttonSizeY));
		
		// Button: Starte 
		startSort = new Button(buttonGroup, SWT.PUSH);
		startSort.setText("Starte " + sortCombo.getText());
		startSort.setLayoutData(new RowData((int)(gridSizeX-15), buttonSizeY));
		
		// Gruppe: Messergebnisse
		messGroup = new Group(control, SWT.BORDER);
		RowLayout messLayout = new RowLayout();
		messLayout.type = SWT.VERTICAL;
		messGroup.setLayout(messLayout);
		messGroup.setText("Messergebnisse:");
		messGroup.setVisible(false);

		// Die jeweiligen Ergebnisse der einzelnen Messmethoden auf der Messergebnisse-Gruppe
		bubbleErgebnis = new Label(messGroup, SWT.None);
		bubbleErgebnis.setLayoutData(new RowData((int)(gridSizeX-20), buttonSizeY));
		selectionErgebnis = new Label(messGroup, SWT.None);
		selectionErgebnis.setLayoutData(new RowData((int)(gridSizeX-20), buttonSizeY));
		insertionErgebnis = new Label(messGroup, SWT.None);
		insertionErgebnis.setLayoutData(new RowData((int)(gridSizeX-20), buttonSizeY));
		mergeErgebnis = new Label(messGroup, SWT.None);
		mergeErgebnis.setLayoutData(new RowData((int)(gridSizeX-20), buttonSizeY));
		heapErgebnis = new Label(messGroup, SWT.None);
		heapErgebnis.setLayoutData(new RowData((int)(gridSizeX-20), buttonSizeY));
		quickErgebnis = new Label(messGroup, SWT.None);
		quickErgebnis.setLayoutData(new RowData((int)(gridSizeX-20), buttonSizeY));

		// unsichtbare Buttons definieren, um den Abstand des Beenden Buttons hinzubekommen (nerdi, ich weiss ;D)
		Button b = new Button(buttonGroup,SWT.PUSH);
		Button b2= new Button(buttonGroup,SWT.PUSH);
		Button b3= new Button(buttonGroup,SWT.PUSH);
		Button b4= new Button(buttonGroup,SWT.PUSH);
		Button b5= new Button(buttonGroup,SWT.PUSH);
		b.setVisible(false);
		b2.setVisible(false);
		b3.setVisible(false);
		b4.setVisible(false);
		b5.setVisible(false);
		
		// Button: Beenden
		Button endProgram = new Button(buttonGroup, SWT.PUSH);
		endProgram.setText("Beenden");
				
		/*****************************************************
		 * Bedienelemente erstellen (NO Click/Change-Handling)
		 * Position: ENDE
		 */
		
		
		/*****************************************************
		 * Click/Change-Handling der Bedienelemente erstellen
		 * Position: BEGINN
		 */
		
		// Waehlt Messmethode (Zeichnen oder Messen) aus
		messen.addSelectionListener(new SelectionAdapter()
		{
			public void widgetSelected(SelectionEvent e)
			{
				if (diagCombo.isEnabled())
				{
					diagCombo.setEnabled(false);
					dc.setVisible(false);
					messGroup.setVisible(true);

				}
				else
				{
					diagCombo.setEnabled(true);
					dc.setVisible(true);
					messGroup.setVisible(false);
				}

			}
		});
		
		// Waehlt Darstellung (Graph oder Bar) aus
		diagCombo.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				switch (diagCombo.getSelectionIndex()) {
				case 0:
					dc.removePaintListener(bDrawer);
					dc.addPaintListener(gDrawer);
					dc.setLayoutData(dcLayout);
					currentDrawer = gDrawer;
					break;
				case 1:
					dc.removePaintListener(gDrawer);
					dc.addPaintListener(bDrawer);
					dc.setLayoutData(dcLayout);
					currentDrawer = bDrawer;
					break;
				}
			}
		});
		
		// Erstellt neues Array je nach Auswahl in der Vorsortierungs-DropDown-Box
		createArray.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				switch (vorsortierung.getSelectionIndex()) {
				case 0:
					newRandomArray();
					break;
				case 1:
					newSortedArray();
					break;
				case 2:
					newReverseArray();
					break;
				case 3:
					newGaussArray();
					break;
				}

				update(values);
			}
		});
		
		// Führt ausgewaehltes Sortierverfahren aus
		startSort.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				switch (sortCombo.getSelectionIndex()) {
				case 0: {
//					messe Zeit...
					sort.bubbleSort(values);
					if (messen.getSelection()) {
//						bubbleErgebnis.setText("Zeit fuer "
//						+ sortCombo.getText() + ": " + zeit + "ms");
					}
				}
				break;
				case 1: {
//					messe Zeit...
					sort.selectionSort(values);
					if (messen.getSelection()) {
//						bubbleErgebnis.setText("Zeit fuer "
//						+ sortCombo.getText() + ": " + zeit + "ms");
					}
				}
				break;
				case 2: {
//					messe Zeit...
					sort.insertionSort(values);
					if (messen.getSelection()) {
//						bubbleErgebnis.setText("Zeit fuer "
//						+ sortCombo.getText() + ": " + zeit + "ms");
					}
				}
				break;
				case 3: {
//					messe Zeit...
					sort.mergeSort(values);
					if (messen.getSelection()) {
//						bubbleErgebnis.setText("Zeit fuer "
//						+ sortCombo.getText() + ": " + zeit + "ms");
					}
				}
				break;
				}
			}
		});

		// Setzt den Text für den Starten-Button dynamisch nach dem ausgewaehlten Sortierverfahren aus
		sortCombo.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				startSort.setText("Starte " + sortCombo.getText());
			}
		});	
		
		// Beende das Programm, wenn der Beenden-Button gedrueckt wurde
		endProgram.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				System.exit(0);
			}
		});
		
		/*****************************************************
		 * Click/Change-Handling der Bedienelemente erstellen
		 * Position: ENDE
		 */

	}

	private void newRandomArray() {
		int size = spinner.getSelection();
		values = new int[size];
		Random random = new Random();
		for (int i = 0; i < size; i++) {
			values[i] = random.nextInt(size) + 1;
			// values[i] = size - i;
		}
	}

	private void newSortedArray() {
		int size = spinner.getSelection();
		values = new int[size];
		for (int i = 0; i < size; i++) {
			values[i] = i + 1;
		}
	}

	private void newReverseArray() {
		int size = spinner.getSelection();
		values = new int[size];
		for (int i = 0; i < size; i++) {
			values[i] = size - i + 1;
		}
	}

	private void newGaussArray() {
		int size = spinner.getSelection();
		values = new int[size];
		double[] gausarray = new double[size];
		Random random = new Random();
		for (int i = 0; i < size; i++) {
			gausarray[i] = random.nextGaussian();
		}
		double min = gausarray[0];
		for (int i = 0; i < size; i++) {
			if (min > gausarray[i]) {
				min = gausarray[i];
			}
		}
		for (int i = 0; i < size; i++) {
			gausarray[i] -= min;
		}

		double max = gausarray[0];
		for (int i = 0; i < size; i++) {
			if (max < gausarray[i]) {
				max = gausarray[i];
			}
		}
		for (int i = 0; i < size; i++) {
			values[i] = (int) Math.round(gausarray[i] * (size / max));
		}
	}

	public void run() {
		shell.open();
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch())
				display.sleep();
		}
		display.dispose();
	}

	public void update(int[] values) {
		if (zeichnen.getSelection()) {
			currentDrawer.setArray(values);
			dc.update();dc.redraw();

		}
	}

	public void updateNoScale(int[] values) {
		if (zeichnen.getSelection()) {
			currentDrawer.setArray(values);
			currentDrawer.setScale(false);
			dc.update();dc.redraw();

			currentDrawer.setScale(true);
		}
	}
}