/************************************************************************************
 * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University
 * All rights reserved.
 * Refer to LICENSE for terms and conditions of use.
 ***********************************************************************************/
package vnsim.gui.selector;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.Spring;
import javax.swing.SpringLayout;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

import vnsim.gui.MapLoader;
import vnsim.gui.Utils;
import vnsim.map.object.Map;
import vnsim.vehicular.scenarios.MainSMFCreator;
import vnsim.vehicular.scenarios.Route;
import vnsim.vehicular.scenarios.Scenario;
import vnsim.vehicular.scenarios.ScenarioMap;
import vnsim.vehicular.simulator.Location;
import vnsim.vehicular.simulator.RouteSegment;

/**
 * 
 * @author Simion Liviu Mihai
 * 
 */
public class RouteConfiguration extends JFrame {

	/** Logger used by this class */
	private static final transient Logger logger = Logger.getLogger("vnsim.gui.selector.RouteConfiguration");

	public static String mapsDir = "/maps/map/";

	public static String routeDir = "/maps/routefiles/";

	private static final long serialVersionUID = -2314871286334244756L;

	int selectedEntryIdx = 0;

	JPanel entryPane;

	JScrollPane entryScroll;

	ScenarioMap inScenario;

	Scenario outScenario;

	JButton deleteRoute, saveScenario, addParam, cancel, AddNewRoute, AddNewEntry, AddNewExit, cancelRoute;

	Map tempMap;

	EntryExitConfig entryConfig;

	JComboBox entry;

	JComboBox exit;

	JComboBox rutemarcate;

	JTextField numeSave, currentroad, currentpoint, selectedroad, selectedpoint;

	JLabel saveAs, entrys, exits, params, currentRoad, currentPoint, selectedRoad, selectedPoint, ruteMarcate;

	RouteConfiguration backRef;

	LocalActionListener lal;

	RouteDraw routeDraw;

	ArrayList<ArrayList<Location>> allRoutes = new ArrayList<ArrayList<Location>>();

	private static RouteConfiguration _instance = null;

	private RouteDesigner rd = null;

	private void showRoute() {
		routeDraw.isRouteShowing = true;
		routeDraw.start = allRoutes.get(rutemarcate.getSelectedIndex()).get(0);
		routeDraw.stop = allRoutes.get(rutemarcate.getSelectedIndex()).get(
				allRoutes.get(rutemarcate.getSelectedIndex()).size() - 1);
		routeDraw.routePoints = allRoutes.get(rutemarcate.getSelectedIndex());
		routeDraw.currentRoute = new Route();
		routeDraw.currentRoute.entry = routeDraw.start;
		routeDraw.currentRoute.exit = routeDraw.start;
		routeDraw.currentRoute.route = new ArrayList<RouteSegment>();
		for (int i = 0; i < allRoutes.get(rutemarcate.getSelectedIndex()).size() - 1; i += 1) {
			Location l1 = allRoutes.get(rutemarcate.getSelectedIndex()).get(i);
			System.err.println(i + " : " + l1.roadIdx + " " + l1.ptIdx);

		}
		for (int i = 0; i < allRoutes.get(rutemarcate.getSelectedIndex()).size() - 1; i += 1) {
			Location l1 = allRoutes.get(rutemarcate.getSelectedIndex()).get(i);
			Location l2 = allRoutes.get(rutemarcate.getSelectedIndex()).get(i + 1);
			System.err.println(i + " : " + l1.roadIdx + " " + l1.ptIdx + " : " + l2.roadIdx + " " + l2.ptIdx);
			if (l1.roadIdx == l2.roadIdx) {
				routeDraw.currentRoute.route.add(new RouteSegment((short) l1.roadIdx, (short) l1.ptIdx,
						(short) l2.ptIdx));
			}
		}
	}

	/**
	 * 
	 * @author Simion Liviu Mihai
	 * 
	 */
	public class LocalActionListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if (e.getSource().equals(saveScenario)) {
				String s = null;
				s = numeSave.getText();
				if (s != null) {
					outScenario.name = s;
				}
				saveScenario();
				routeDraw.isRouteShowing = false;
				routeDraw.currentRoute = null;
				rd.afterExit();
				backRef.setVisible(false);
				MapLoader.show(true);
				return;
			}
			if (e.getSource().equals(cancel)) {
				backRef.setVisible(false);
				MapLoader.show(true);
				return;
			}
			if (e.getSource().equals(AddNewEntry)) {
				if (routeDraw.currentLocation != null) {
					routeDraw.entrys.add(routeDraw.currentLocation);
					entry.addItem(String.valueOf(routeDraw.entrys.size()));
					routeDraw.isRouteEditing = false;
					entry.setSelectedIndex(entry.getItemCount() - 1);
					routeDraw.setStart(routeDraw.entrys.get(routeDraw.entrys.size() - 1));
				}
				routeDraw.isRouteShowing = false;
				routeDraw.currentRoute = null;
				deleteRoute.setEnabled(false);
				return;
			}
			if (e.getSource().equals(AddNewExit)) {
				if (routeDraw.currentLocation != null) {
					routeDraw.exits.add(routeDraw.currentLocation);
					exit.addItem(String.valueOf(routeDraw.exits.size()));
					routeDraw.isRouteEditing = false;
					routeDraw.currentRoute = null;
					exit.setSelectedIndex(exit.getItemCount() - 1);
					routeDraw.setStop(routeDraw.exits.get(routeDraw.exits.size() - 1));
				}
				routeDraw.isRouteShowing = false;
				deleteRoute.setEnabled(false);
				return;
			}
			if (e.getSource().equals(rutemarcate)) {
				System.err.println(rutemarcate.getSelectedIndex() + " : " + allRoutes.size());
				if (rutemarcate.getSelectedIndex() != -1) {
					deleteRoute.setEnabled(true);
					System.err.println(allRoutes.get(rutemarcate.getSelectedIndex()).size());
					showRoute();
				}
				return;
			}
			if (e.getSource().equals(entry)) {
				if ((routeDraw.entrys != null) && (entry.getSelectedIndex() != -1)) {
					routeDraw.setStart(routeDraw.entrys.get(Integer.parseInt((String) entry.getSelectedItem()) - 1));
					// routeDraw.start = ;
					routeDraw.isRouteEditing = false;
					routeDraw.isRouteShowing = false;
					routeDraw.currentRoute = null;
					deleteRoute.setEnabled(false);
				}
				return;
			}
			if (e.getSource().equals(exit)) {
				if ((routeDraw.exits != null) && (exit.getSelectedIndex() != -1)) {
					routeDraw.stop = routeDraw.exits.get(Integer.parseInt((String) exit.getSelectedItem()) - 1);
					routeDraw.isRouteEditing = false;
					routeDraw.isRouteShowing = false;
					deleteRoute.setEnabled(false);
					routeDraw.currentRoute = null;
				}
				return;
			}
			if (e.getSource().equals(cancelRoute)) {	
				AddNewRoute.setText("Make route");
				routeDraw.isRouteEditing = false;
				routeDraw.routePoints = new ArrayList<Location>();
				routeDraw.isRouteShowing = false;
				routeDraw.currentRoute = null;
				deleteRoute.setEnabled(false);
				return;
			}
			if (e.getSource().equals(deleteRoute)) {
				if (allRoutes.size() == 0) {
					return;
				}
				allRoutes.remove(rutemarcate.getSelectedIndex());
				rutemarcate.removeItemAt(rutemarcate.getSelectedIndex());
				if (allRoutes.size() > 0) {
					rutemarcate.setSelectedIndex(0);
					routeDraw.start = allRoutes.get(0).get(0);
					routeDraw.stop = allRoutes.get(0).get(allRoutes.get(0).size() - 1);
					routeDraw.routePoints = allRoutes.get(0);
					showRoute();
				} else {
					deleteRoute.setEnabled(false);
					routeDraw.isRouteShowing = false;
					routeDraw.isRouteEditing = false;
					routeDraw.currentRoute = null;
				}
				rutemarcate.validate();
				rutemarcate.revalidate();
				return;
			}
			if (e.getSource().equals(AddNewRoute)) {
				if ((entry.getSelectedIndex() == -1) || (exit.getSelectedIndex() == -1)) {
					return;
				}
				if (AddNewRoute.getText().charAt(0) == 'M') {
					cancelRoute.setEnabled(true);
					AddNewRoute.setText("Add route");
					routeDraw.isRouteEditing = true;
					routeDraw.routePoints = new ArrayList<Location>();
					routeDraw.routePoints.add(routeDraw.start);
					routeDraw.currentRoute = new Route();
					routeDraw.currentRoute.entry = routeDraw.start;
					routeDraw.currentRoute.entry = routeDraw.stop;
					routeDraw.currentRoute.route = new ArrayList<RouteSegment>();
				} else if (AddNewRoute.getText().contains("Add")) {
					routeDraw.currentRoute = null;
					routeDraw.routePoints.add(routeDraw.stop);
					AddNewRoute.setText("Make route");
					if (routeDraw.routePoints.get(routeDraw.routePoints.size()-2).roadIdx!=routeDraw.routePoints.get(routeDraw.routePoints.size()-1).roadIdx){
						int ret=JOptionPane.showConfirmDialog(null, "The route is incomplete! Would you like to finish it?");
						if (ret==JOptionPane.NO_OPTION){
							AddNewRoute.setText("Make route");
							routeDraw.isRouteEditing = false;
							routeDraw.routePoints = new ArrayList<Location>();
							routeDraw.isRouteShowing = false;
							routeDraw.currentRoute = null;
							deleteRoute.setEnabled(false);
							return;					
						}
					}
					allRoutes.add(routeDraw.routePoints);
					routeDraw.isRouteEditing = false;
					routeDraw.isRouteShowing = true;
					routeDraw.routePoints = new ArrayList<Location>();
					rutemarcate.addItem(((String) entry.getSelectedItem()) + "->" + ((String) exit.getSelectedItem()));
					cancelRoute.setEnabled(false);
					showRoute();
				}
				routeDraw.isRouteShowing = false;
				deleteRoute.setEnabled(false);
			}
		}

		/**
		 * 
		 */
		private void saveScenario() {
			// TODO Auto-generated method stub
			// Creeaza fisierul TXT cu rutele
			System.err.println("Am inceput de scris " + allRoutes.size());
			try {
				PrintStream ps = new PrintStream(new File("." + File.separatorChar
						+ MainSMFCreator.routeDir.replace('/', File.separatorChar) + numeSave.getText() + ".txt"));
				ps.println(routeDraw.exits.size() + " exits");
				for (int i = 0; i < routeDraw.exits.size(); i++) {
					ps.println("\t" + routeDraw.exits.get(i).roadIdx + " " + routeDraw.exits.get(i).ptIdx + " ");
				}
				ps.println(routeDraw.exits.size() + " entries ");
				System.err.println(allRoutes.get(0).get(0).roadIdx + " : " + allRoutes.get(0).get(0).ptIdx);
				for (int i = 0; i < routeDraw.entrys.size(); i++) {
					ps.println(routeDraw.entrys.get(i).roadIdx + " " + routeDraw.entrys.get(i).ptIdx);
					int routesnr = 0;
					for (int j = 0; j < allRoutes.size(); j++) {
						if (allRoutes.get(j).get(0).equals(routeDraw.entrys.get(i))) {
							routesnr++;
						}
					}
					ps.println("\t" + routesnr + " routes");
					for (int j = 0; j < allRoutes.size(); j++) {
						if (allRoutes.get(j).get(0).equals(routeDraw.entrys.get(i))) {
							ps.println("\tTO " + allRoutes.get(j).get(allRoutes.get(j).size() - 1).roadIdx + " "
									+ allRoutes.get(j).get(allRoutes.get(j).size() - 1).ptIdx);
							int segments = 0;
							for (int k = 1; k < allRoutes.get(j).size(); k++) {
								if (allRoutes.get(j).get(k).roadIdx == allRoutes.get(j).get(k - 1).roadIdx) {
									segments++;
								}
							}
							ps.println("\t\t" + segments + " segments");
							for (int k = 1; k < allRoutes.get(j).size(); k++) {
								if (allRoutes.get(j).get(k).roadIdx == allRoutes.get(j).get(k - 1).roadIdx) {
									ps.println("\t\t" + allRoutes.get(j).get(k).roadIdx + " "
											+ allRoutes.get(j).get(k - 1).ptIdx + " " + allRoutes.get(j).get(k).ptIdx);
								}
							}
						}
					}
				}
				ps.close();
				try {
					ArrayList<String> driverTypes = new ArrayList<String>();
					driverTypes.add("very calm");
					driverTypes.add("regular");
					driverTypes.add("aggresive");
					String name = numeSave.getText();
					String routeFile = name + ".txt";
					ScenarioMap scen = new ScenarioMap();
					scen.name = name;
					scen.imageFileName = "/images/none.png";
					scen.driverTypes = driverTypes;
					scen.mapFileName = inScenario.mapFileName;
					System.err.println("-> " + scen.mapFileName);
					try {
						MainSMFCreator.loadScenarioData(routeDir + routeFile, scen);
					} catch (Exception ex) {
						logger.severe("Got exception loading scenario data " + ex.getLocalizedMessage());
					}
					final String dir = System.getProperty("user.home") + File.separatorChar + "maps"
							+ File.separatorChar + "smf";
					(new File(dir)).mkdirs();
					ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(dir + File.separatorChar
							+ name + ".smf"));
					oos.writeObject(scen);
					oos.close();
					MapLoader.refreshSMF();
				} catch (Exception ex) {
					logger.log(Level.SEVERE, "Could not create SMF file", ex);
				}
			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}

	}

	/**
	 * 
	 * @param l
	 */
	public void addEntry(Location l) {
		inScenario.entries.add(l);
		inScenario.exits.add(l);
		outScenario.entries.add(l);
		outScenario.exits.add(l);
	}

	public static RouteConfiguration getInstance(RouteDesigner rd, ScenarioMap s, Scenario outScen) {
		if (_instance != null) {
			_instance.dispose();
			_instance = null;
		}
		_instance = new RouteConfiguration(rd, s, outScen);
		return _instance;
	}

	/**
	 * @param s
	 * @param m
	 * @param outScen
	 */
	public RouteConfiguration(RouteDesigner rd, ScenarioMap s, Scenario outScen) {
		super("Configure simulation!");
		backRef = this;
		this.rd = rd;
		this.inScenario = s;
		this.outScenario = outScen;
		if (outScen == null) {
			this.outScenario = new Scenario(s.mapFileName, s.entries, s.exits, s.driverTypes, s.allRoutes, s.name);
		} else {
			this.outScenario = outScen;
		}
		allRoutes = new ArrayList<ArrayList<Location>>();
		// System.err.println("!@!@!@ " + s.entries.size());
		SpringLayout layout1 = new SpringLayout();
		this.getContentPane().setLayout(layout1);
		SpringLayout.Constraints constrain;
		entryPane = new JPanel();
		entryPane.setLayout(layout1);
		lal = new LocalActionListener();
		entry = new JComboBox();
		System.out.println("Harta este: " + inScenario.mapFileName);
		Map tempMap = null;
		try {
			ObjectInputStream ois = null;
			if (inScenario.mapFileName.startsWith("."))
				inScenario.mapFileName = inScenario.mapFileName.substring(1);
			String path = System.getProperty("user.home") + File.separatorChar
					+ inScenario.mapFileName.replace('\\', File.separatorChar).replace('/', File.separatorChar);
			File f = new File(path);
			if (f.exists() && f.isFile() && f.canRead())
				ois = new ObjectInputStream(new FileInputStream(path));
			else {
				ois = new ObjectInputStream(Utils.getInstance().openStream(inScenario.mapFileName.replace('\\', '/')));
			}
			tempMap = (Map) ois.readObject();
			ois.close();
		} catch (Exception ex) {
			// logger.log(Level.SEVERE,
			// "Got exception for "+inScenario.mapFileName, ex);
		}
		routeDraw = new RouteDraw(this, 1000 - 170, 700 - 55, tempMap);
		entry.addActionListener(lal);
		exit = new JComboBox();
		exit.addActionListener(lal);
		numeSave = new JTextField();
		currentpoint = new JTextField();
		currentroad = new JTextField();
		currentpoint.setEditable(false);
		currentroad.setEditable(false);
		rutemarcate = new JComboBox();

		selectedpoint = new JTextField();
		selectedroad = new JTextField();
		selectedpoint.setEditable(false);
		selectedroad.setEditable(false);

		numeSave.setText(s.name);
		saveAs = new JLabel("Save scenario as: ");
		params = new JLabel("Current route: ");
		entrys = new JLabel("Entry : ");
		exits = new JLabel("Exit   : ");
		ruteMarcate = new JLabel("Existing routes: ");
		currentRoad = new JLabel("Current road: ");
		currentPoint = new JLabel("Current point: ");
		selectedRoad = new JLabel("Selected road: ");
		selectedPoint = new JLabel("Selected point: ");
		saveScenario = new JButton("Save");
		cancel = new JButton("Cancel");
		AddNewRoute = new JButton("Make route");
		AddNewEntry = new JButton("Add entry");
		AddNewExit = new JButton("Add exit");
		cancelRoute = new JButton("Cancel route");
		deleteRoute = new JButton("Delete route");
		deleteRoute.setEnabled(false);
		cancelRoute.setEnabled(false);
		for (int i = 0; i < s.entries.size(); i++) {
			routeDraw.entrys.add(s.entries.get(i));
			entry.addItem(String.valueOf(i + 1));
		}
		for (int i = 0; i < s.exits.size(); i++) {
			routeDraw.exits.add(s.exits.get(i));
			exit.addItem(String.valueOf(i + 1));
		}
		for (int i = 0; i < s.allRoutes.size(); i++) {
			int cent = 0;
			int cex = 0;
			for (int j = 0; j < s.entries.size(); j++) {
				if (s.entries.get(j).equals(s.allRoutes.get(i).entry)) {
					cent = i + 1;
					break;
				}
			}
			for (int j = 0; j < s.exits.size(); j++) {
				if (s.exits.get(j).equals(s.allRoutes.get(i).exit)) {
					cex = i + 1;
					break;
				}
			}
			rutemarcate.addItem((String) (String.valueOf(cent) + "->" + String.valueOf(cex)));
			allRoutes.add(new ArrayList<Location>());
			for (int j = 0; j < s.allRoutes.get(i).route.size(); j++) {
				allRoutes.get(allRoutes.size() - 1).add(
						new Location(s.allRoutes.get(i).route.get(j).roadIndex, s.allRoutes.get(i).route.get(j).pt1));
				allRoutes.get(allRoutes.size() - 1).add(
						new Location(s.allRoutes.get(i).route.get(j).roadIndex, s.allRoutes.get(i).route.get(j).pt2));
			}
			System.err.println("Am gasit " + allRoutes.size() + " intrari");
		}
		SpringLayout.Constraints entryConstraint = layout1.getConstraints(entry);
		SpringLayout.Constraints exitConstraint = layout1.getConstraints(exit);
		SpringLayout.Constraints addentryConstraint = layout1.getConstraints(AddNewEntry);
		SpringLayout.Constraints addexitConstraint = layout1.getConstraints(AddNewExit);
		SpringLayout.Constraints addrouteConstraint = layout1.getConstraints(AddNewRoute);
		SpringLayout.Constraints cancelConstraint = layout1.getConstraints(cancel);
		SpringLayout.Constraints numeSaveConstraint = layout1.getConstraints(numeSave);
		SpringLayout.Constraints saveScenarioConstraint = layout1.getConstraints(saveScenario);
		SpringLayout.Constraints saveasConstraint = layout1.getConstraints(saveAs);
		SpringLayout.Constraints entrysConstraint = layout1.getConstraints(entrys);
		SpringLayout.Constraints exitsConstraint = layout1.getConstraints(exits);
		SpringLayout.Constraints paramsConstraint = layout1.getConstraints(params);
		SpringLayout.Constraints currentpointConstraint = layout1.getConstraints(currentpoint);
		SpringLayout.Constraints currentPointConstraint = layout1.getConstraints(currentPoint);
		SpringLayout.Constraints currentroadConstraint = layout1.getConstraints(currentroad);
		SpringLayout.Constraints currentRoadConstraint = layout1.getConstraints(currentRoad);
		SpringLayout.Constraints selectedpointConstraint = layout1.getConstraints(selectedpoint);
		SpringLayout.Constraints selectedPointConstraint = layout1.getConstraints(selectedPoint);
		SpringLayout.Constraints selectedroadConstraint = layout1.getConstraints(selectedroad);
		SpringLayout.Constraints selectedRoadConstraint = layout1.getConstraints(selectedRoad);
		SpringLayout.Constraints cancelRouteConstraint = layout1.getConstraints(cancelRoute);
		SpringLayout.Constraints rutemarcateConstraints = layout1.getConstraints(rutemarcate);
		SpringLayout.Constraints ruteMarcateConstraints = layout1.getConstraints(ruteMarcate);
		SpringLayout.Constraints deleteRouteConstraint = layout1.getConstraints(deleteRoute);

		currentRoadConstraint.setX(Spring.constant(10));
		currentRoadConstraint.setY(Spring.constant(10));
		currentRoadConstraint.setWidth(Spring.constant(110));
		currentRoadConstraint.setHeight(Spring.constant(15));

		currentroadConstraint.setX(Spring.constant(10));
		currentroadConstraint.setY(Spring.constant(35));
		currentroadConstraint.setWidth(Spring.constant(110));
		currentroadConstraint.setHeight(Spring.constant(20));

		currentPointConstraint.setX(Spring.constant(10));
		currentPointConstraint.setY(Spring.constant(65));
		currentPointConstraint.setWidth(Spring.constant(110));
		currentPointConstraint.setHeight(Spring.constant(15));

		currentpointConstraint.setX(Spring.constant(10));
		currentpointConstraint.setY(Spring.constant(90));
		currentpointConstraint.setWidth(Spring.constant(110));
		currentpointConstraint.setHeight(Spring.constant(20));

		selectedRoadConstraint.setX(Spring.constant(10));
		selectedRoadConstraint.setY(Spring.constant(115));
		selectedRoadConstraint.setWidth(Spring.constant(110));
		selectedRoadConstraint.setHeight(Spring.constant(15));

		selectedroadConstraint.setX(Spring.constant(10));
		selectedroadConstraint.setY(Spring.constant(140));
		selectedroadConstraint.setWidth(Spring.constant(110));
		selectedroadConstraint.setHeight(Spring.constant(20));

		selectedPointConstraint.setX(Spring.constant(10));
		selectedPointConstraint.setY(Spring.constant(170));
		selectedPointConstraint.setWidth(Spring.constant(110));
		selectedPointConstraint.setHeight(Spring.constant(15));

		selectedpointConstraint.setX(Spring.constant(10));
		selectedpointConstraint.setY(Spring.constant(195));
		selectedpointConstraint.setWidth(Spring.constant(110));
		selectedpointConstraint.setHeight(Spring.constant(20));

		addentryConstraint.setX(Spring.constant(10));
		addentryConstraint.setY(Spring.constant(220));
		addentryConstraint.setWidth(Spring.constant(110));
		addentryConstraint.setHeight(Spring.constant(20));

		addexitConstraint.setX(Spring.constant(10));
		addexitConstraint.setY(Spring.constant(242));
		addexitConstraint.setWidth(Spring.constant(110));
		addexitConstraint.setHeight(Spring.constant(20));

		ruteMarcateConstraints.setX(Spring.constant(10));
		ruteMarcateConstraints.setY(Spring.constant(270));
		ruteMarcateConstraints.setWidth(Spring.constant(110));
		ruteMarcateConstraints.setHeight(Spring.constant(20));

		rutemarcateConstraints.setX(Spring.constant(10));
		rutemarcateConstraints.setY(Spring.constant(292));
		rutemarcateConstraints.setWidth(Spring.constant(110));
		rutemarcateConstraints.setHeight(Spring.constant(20));

		paramsConstraint.setX(Spring.constant(10));
		paramsConstraint.setY(Spring.constant(320));
		paramsConstraint.setWidth(Spring.constant(200));
		paramsConstraint.setHeight(Spring.constant(10));

		entrysConstraint.setX(Spring.constant(10));
		entrysConstraint.setY(Spring.constant(336));
		entrysConstraint.setWidth(Spring.constant(50));
		entrysConstraint.setHeight(Spring.constant(15));

		exitsConstraint.setX(Spring.constant(10));
		exitsConstraint.setY(Spring.constant(361));
		exitsConstraint.setWidth(Spring.constant(50));
		exitsConstraint.setHeight(Spring.constant(10));

		entryConstraint.setX(Spring.constant(50));
		entryConstraint.setY(Spring.constant(335));
		entryConstraint.setWidth(Spring.constant(70));
		entryConstraint.setHeight(Spring.constant(20));

		exitConstraint.setX(Spring.constant(50));
		exitConstraint.setY(Spring.constant(358));
		exitConstraint.setWidth(Spring.constant(70));
		exitConstraint.setHeight(Spring.constant(20));

		addrouteConstraint.setX(Spring.constant(10));
		addrouteConstraint.setY(Spring.constant(380));
		addrouteConstraint.setWidth(Spring.constant(110));
		addrouteConstraint.setHeight(Spring.constant(20));

		cancelRouteConstraint.setX(Spring.constant(10));
		cancelRouteConstraint.setY(Spring.constant(402));
		cancelRouteConstraint.setWidth(Spring.constant(110));
		cancelRouteConstraint.setHeight(Spring.constant(20));

		deleteRouteConstraint.setX(Spring.constant(10));
		deleteRouteConstraint.setY(Spring.constant(424));
		deleteRouteConstraint.setWidth(Spring.constant(110));
		deleteRouteConstraint.setHeight(Spring.constant(20));

		saveasConstraint.setX(Spring.constant(10));
		saveasConstraint.setY(Spring.constant(443));
		saveasConstraint.setWidth(Spring.constant(110));
		saveasConstraint.setHeight(Spring.constant(20));

		numeSaveConstraint.setX(Spring.constant(10));
		numeSaveConstraint.setY(Spring.constant(475));
		numeSaveConstraint.setWidth(Spring.constant(110));
		numeSaveConstraint.setHeight(Spring.constant(20));

		saveScenarioConstraint.setX(Spring.constant(10));
		saveScenarioConstraint.setY(Spring.constant(493));
		saveScenarioConstraint.setWidth(Spring.constant(110));
		saveScenarioConstraint.setHeight(Spring.constant(20));

		cancelConstraint.setX(Spring.constant(10));
		cancelConstraint.setY(Spring.constant(520));
		cancelConstraint.setWidth(Spring.constant(110));
		cancelConstraint.setHeight(Spring.constant(20));

		saveScenario.addActionListener(lal);
		cancel.addActionListener(lal);
		AddNewRoute.addActionListener(lal);
		AddNewEntry.addActionListener(lal);
		AddNewExit.addActionListener(lal);
		rutemarcate.addActionListener(lal);
		deleteRoute.addActionListener(lal);
		cancelRoute.addActionListener(lal);

		entryPane.add(params);
		entryPane.add(entrys);
		entryPane.add(exits);
		entryPane.add(entry);
		entryPane.add(exit);
		entryPane.add(saveAs);
		entryPane.add(saveScenario);
		entryPane.add(cancel);
		entryPane.add(AddNewEntry);
		entryPane.add(AddNewExit);
		entryPane.add(AddNewRoute);
		entryPane.add(numeSave);
		entryPane.add(currentPoint);
		entryPane.add(currentpoint);
		entryPane.add(currentroad);
		entryPane.add(currentRoad);
		entryPane.add(selectedPoint);
		entryPane.add(selectedpoint);
		entryPane.add(selectedroad);
		entryPane.add(selectedRoad);
		entryPane.add(cancelRoute);
		entryPane.add(ruteMarcate);
		entryPane.add(rutemarcate);
		entryPane.add(deleteRoute);

		this.getContentPane().add(entryPane);

		constrain = layout1.getConstraints(entryPane);
		constrain.setX(Spring.constant(2));
		constrain.setY(Spring.constant(2));
		constrain.setWidth(Spring.constant(130));
		constrain.setHeight(Spring.constant(580));

		this.getContentPane().add(this.routeDraw);
		routeDraw.setBorder(BorderFactory.createEtchedBorder());

		constrain = layout1.getConstraints(this.routeDraw);
		constrain.setX(Spring.constant(135));
		constrain.setY(Spring.constant(2));
		constrain.setWidth(Spring.constant(1000 - 150));
		constrain.setHeight(Spring.constant(700 - 40));

		routeDraw.setVisible(true);
		routeDraw.repaint();
		this.setSize(1000, 700);
		this.setLocation(10, 10);
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
		this.setVisible(true);
		this.getContentPane().repaint();
	}

	/**
	 * 
	 * @return
	 */
	public Scenario getScenario() {
		return this.outScenario;
	}

	/**
	 * 
	 * @param outScenario
	 */
	public void configurationResult(Scenario outScenario) {
		this.outScenario = outScenario;
		this.setVisible(true);
		repaint();
		this.entryConfig = null;
	}
}