/************************************************************************************
 * 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 javax.swing.*;

import vnsim.map.object.Map;
import vnsim.vehicular.scenarios.EntryExitScenario;
import vnsim.vehicular.scenarios.EntryScenario;
import vnsim.vehicular.scenarios.Route;
import vnsim.vehicular.scenarios.Scenario;
import vnsim.vehicular.scenarios.ScenarioMap;
import vnsim.vehicular.simulator.Location;
import vnsim.gui.Utils;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;
import java.util.logging.Logger;
import java.util.logging.Level;
import java.io.*;

public class EntryExitConfig extends JPanel {

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

	/**
	 * 
	 */
	private static final long serialVersionUID = -2386010293426825417L;

	ScenarioMap inScenario;

	EntryScenario currentEntryScenario;

	Location currentEntry;

	JPanel mainConfig;

	Vector<Integer> validExits;

	RouteSelector routePanel;

	int hight;

	JLabel flow, exitLabel;

	JLabel[] driverTypes;

	JTextField flowValue;

	JTextField[] driverTypesValue;

	JButton[] routeName;

	JTextField[] routeProcents;

	JComboBox exitSelect;

	Scenario outScenario;

	ScenarioConfiguration sc = null;

	myActionListener myListener;

	EntryExitScenario currentEntryExitScenario;

	public class myActionListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if (e.getSource() == exitSelect) {
				int idx = exitSelect.getSelectedIndex();
				if (idx >= 0) {
					Location newExit = outScenario.exits.get(validExits.elementAt(idx));
					if (!newExit.equals(routePanel.stop)) {
						routePanel.setVisible(false);
						routePanel.saveRouteValues();
						routePanel = new RouteSelector(currentEntry, newExit);
						ScenarioConfiguration.mapRepresentation.setStop(outScenario.exits
								.get(validExits.elementAt(idx)));
						ScenarioConfiguration.mapRepresentation.setRoute(null);
					}
					for (int i = 0; i < outScenario.allRoutes.size(); i++) {
						if (outScenario.allRoutes.get(i).entry.equals(ScenarioConfiguration.mapRepresentation.start)
								&& outScenario.allRoutes.get(i).exit.equals(ScenarioConfiguration.mapRepresentation.stop)) {
							ScenarioConfiguration.mapRepresentation.currentRoute=outScenario.allRoutes.get(i);		
							break;
						}
					}
				}
			}
		}
	}

	public class RouteSelector extends JPanel {
		/**
		 * 
		 */
		private static final long serialVersionUID = -708491299953270966L;
		Location start, stop;

		public RouteSelector(Location start, Location stop) {
			super();
			this.start = start;
			this.stop = stop;
			setPanel();
		}

		public void setPanel() {
			int i = 0, k = 0;
			boolean found = false;
			SpringLayout sp = new SpringLayout();
			this.setLayout(sp);
			SpringLayout.Constraints constraint;
			Route r;
			EntryExitScenario exs = null;
			for (k = 0; k < currentEntryScenario.entryExits.size(); k++) {
				exs = currentEntryScenario.entryExits.get(k);
				if (exs.entry.equals(this.start) && exs.exit.equals(this.stop)) {
					found = true;
					break;
				}
			}
			if (!found) {
				exs = new EntryExitScenario(this.start, this.stop);

				for (k = 0; k < inScenario.allRoutes.size(); k++) {
					r = inScenario.allRoutes.get(k);
					if (r.entry.equals(this.start) && r.exit.equals(this.stop)) {
						exs.routes.add(r);
						exs.percentsEachRoute.add(new Integer(0));
					}
				}
				routeName = new JButton[exs.routes.size()];
				routeProcents = new JTextField[exs.routes.size()];
				for (i = 0; i < exs.routes.size(); i++) {
					routeName[i] = new JButton("Route " + i);
					routeProcents[i] = new JTextField();

					constraint = sp.getConstraints(routeName[i]);
					constraint.setX(Spring.constant(1));
					constraint.setY(Spring.constant(1 + i * 50));
					constraint.setWidth(Spring.constant(100));
					constraint.setHeight(Spring.constant(40));

					constraint = sp.getConstraints(routeProcents[i]);
					constraint.setX(Spring.constant(150));
					constraint.setY(Spring.constant(1 + i * 50));
					constraint.setWidth(Spring.constant(100));
					constraint.setHeight(Spring.constant(40));
					routeName[i].addActionListener(myListener);
					this.add(routeName[i]);
					this.add(routeProcents[i]);
				}
				currentEntryExitScenario = exs;
				currentEntryScenario.entryExits.add(exs);
			} else {
				routeName = new JButton[exs.routes.size()];
				routeProcents = new JTextField[exs.routes.size()];
				// System.out.println("FOR " + this.start + "- " + this.stop
				// + " Exist nr=" + exs.routes.size() + " routes");
				for (i = 0; i < exs.routes.size(); i++) {
					routeName[i] = new JButton("Route " + i);
					routeProcents[i] = new JTextField("" + exs.percentsEachRoute.get(i));
					constraint = sp.getConstraints(routeName[i]);
					constraint.setX(Spring.constant(1));
					constraint.setY(Spring.constant(1 + i * 50));
					constraint.setWidth(Spring.constant(100));
					constraint.setHeight(Spring.constant(40));

					constraint = sp.getConstraints(routeProcents[i]);
					constraint.setX(Spring.constant(150));
					constraint.setY(Spring.constant(1 + i * 50));
					constraint.setWidth(Spring.constant(100));
					constraint.setHeight(Spring.constant(40));
					routeName[i].addActionListener(myListener);
					this.add(routeName[i]);
					this.add(routeProcents[i]);
				}
				currentEntryExitScenario = exs;
			}
			this.setPreferredSize(new Dimension(300, i * 50 + 50));
			this.setVisible(true);
		}

		public void saveRouteValues() {
			int i;
			EntryExitScenario exs = null;
			String text;
			int val;
			exs = currentEntryExitScenario;
			if (exs != null) {
				for (i = 0; i < exs.routes.size() - 1; i++) {
					text = routeProcents[i].getText();
					try {
						val = (new Integer(text)).intValue();
						if (val >= 0) {
							exs.percentsEachRoute.setElementAt(100, i);
						}
					} catch (Exception e) {
					}
				}
				exs.percentOfFlow=100;
			}
		}
	}

	public EntryExitConfig(ScenarioConfiguration sc, ScenarioMap inS, Location entry, Scenario outScenario) {
		super();
		int i;
		this.sc = sc;
		this.inScenario = inS;
		this.currentEntry = entry;
		this.outScenario = outScenario;
		this.myListener = new myActionListener();
		setCurrentEntryScenario();
		int hight = 500 + (50 * inS.driverTypes.size());
		
		SpringLayout l1 = new SpringLayout();
		SpringLayout l2 = new SpringLayout();
		this.setLocation(100, 100);
		this.setLayout(l1);
		// get the map from the file!
		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);
		}

		ScenarioConfiguration.mapRepresentation = new MapPanel(hight-10, hight-10, tempMap);
		ScenarioConfiguration.mapRepresentation.eec = this;
		ScenarioConfiguration.mapRepresentation.setStart(currentEntry);

		mainConfig = new JPanel();
		mainConfig.setSize(198, hight);
		mainConfig.setLayout(l2);
		flow = new JLabel("cars/h/lane");
		exitLabel = new JLabel("Select the exit:");
		flowValue = new JTextField();

		driverTypes = new JLabel[inScenario.driverTypes.size()];
		driverTypesValue = new JTextField[inScenario.driverTypes.size()];
		for (i = 0; i < inScenario.driverTypes.size(); i++) {
			driverTypes[i] = new JLabel(inScenario.driverTypes.get(i));
			driverTypesValue[i] = new JTextField();
		}

		String[] exitString = getValidExits(entry);
		exitSelect = new JComboBox(exitString);
		exitSelect.addActionListener(myListener);
		System.err.println("-" + validExits.size() + " " + entry.roadIdx);
		routePanel = new RouteSelector(entry, outScenario.exits.get(validExits.elementAt(0)));
		ScenarioConfiguration.mapRepresentation.setStop(outScenario.exits.get(validExits.elementAt(0)));

		flow.setSize(100, 40);
		SpringLayout.Constraints constraint;

		constraint = l2.getConstraints(exitLabel);
		constraint.setX(Spring.constant(1));
		constraint.setY(Spring.constant(2));
		constraint.setWidth(Spring.constant(193));
		constraint.setHeight(Spring.constant(20));

		constraint = l2.getConstraints(exitSelect);
		constraint.setX(Spring.constant(1));
		constraint.setY(Spring.constant(25));
		constraint.setWidth(Spring.constant(193));
		constraint.setHeight(Spring.constant(20));

		constraint = l2.getConstraints(flow);
		constraint.setX(Spring.constant(1));
		constraint.setY(Spring.constant(75));
		constraint.setWidth(Spring.constant(100));
		constraint.setHeight(Spring.constant(20));

		constraint = l2.getConstraints(flowValue);
		constraint.setX(Spring.constant(100));
		constraint.setY(Spring.constant(75));
		constraint.setWidth(Spring.constant(93));
		constraint.setHeight(Spring.constant(20));

		for (i = 0; i < inScenario.driverTypes.size(); i++) {

			constraint = l2.getConstraints(driverTypes[i]);
			constraint.setX(Spring.constant(1));
			constraint.setY(Spring.constant(100 + 25 * i));
			constraint.setWidth(Spring.constant(100));
			constraint.setHeight(Spring.constant(20));

			constraint = l2.getConstraints(driverTypesValue[i]);
			constraint.setX(Spring.constant(100));
			constraint.setY(Spring.constant(100 + 25 * i));
			constraint.setWidth(Spring.constant(93));
			constraint.setHeight(Spring.constant(20));

			driverTypes[i].setSize(100, 20);
			driverTypesValue[i].setSize(100, 20);
		}

		exitSelect.setSize(193, 20);
		exitSelect.addActionListener(myListener);

		mainConfig.add(exitLabel);
		mainConfig.add(this.exitSelect);
		mainConfig.add(this.flow);
		mainConfig.add(this.flowValue);
		for (i = 0; i < inScenario.driverTypes.size(); i++) {
			mainConfig.add(this.driverTypes[i]);
			mainConfig.add(this.driverTypesValue[i]);
		}
		mainConfig.setVisible(true);

		constraint = l1.getConstraints(this.mainConfig);
		constraint.setX(Spring.constant(1));
		constraint.setY(Spring.constant(1));
		constraint.setWidth(Spring.constant(195));
		constraint.setHeight(Spring.constant(hight));
		ScenarioConfiguration.mapRepresentation.setSize(hight-10, hight-10);
		ScenarioConfiguration.mapRepresentation.setVisible(true);

		mainConfig.setSize(195, hight);

		this.add(this.mainConfig);
		this.setSize(195, hight);
		fillAllValues();
		this.setVisible(true);

	}

	public void setNewEntry(Location newEntry) {
//		if (!newEntry.equals(currentEntry)) {
			saveChanges();
			this.currentEntry = newEntry;
			String[] exitString = getValidExits(newEntry);
			exitSelect.removeActionListener(this.myListener);
			exitSelect.removeAllItems();
			setCurrentEntryScenario();
			for (int i = 0; i < exitString.length; i++) {
				exitSelect.addItem(exitString[i]);
			}
			if (exitSelect.getItemCount() > 0) {
				exitSelect.addActionListener(this.myListener);
				routePanel.setVisible(false);
				ScenarioConfiguration.mapRepresentation.setRoute(null);
				ScenarioConfiguration.mapRepresentation.setStart(currentEntry);
				ScenarioConfiguration.mapRepresentation.setStop(outScenario.exits.get(validExits.elementAt(0)));
				routePanel = new RouteSelector(currentEntry, outScenario.exits.get(validExits.elementAt(0)));
				fillAllValues();
			}
			exitSelect.setSelectedIndex(0);
//		}

	}

	public void fillAllValues() {
		this.flowValue.setText("" + currentEntryScenario.flow);
		for (int i = 0; i < currentEntryScenario.percentsDriverTypes.size(); i++) {
			this.driverTypesValue[i].setText("" + currentEntryScenario.percentsDriverTypes.get(i));
		}
	}

	public void setCurrentEntryScenario() {
		EntryScenario es;
		for (int i = 0; i < outScenario.entryScenarios.size(); i++) {
			es = outScenario.entryScenarios.get(i);
			if (es.entry.equals(this.currentEntry)) {
				currentEntryScenario = es;
				return;
			}
		}
		es = new EntryScenario(this.currentEntry);
		for (int i = 0; i < inScenario.driverTypes.size(); i++) {
			if (i < inScenario.driverTypes.size() - 1) {
				es.percentsDriverTypes.add(new Integer(100 / inScenario.driverTypes.size()));
			} else {
				es.percentsDriverTypes.add(new Integer(100 - (inScenario.driverTypes.size() - 1)
						* (new Integer(100 / inScenario.driverTypes.size())).intValue()));
			}
		}
		currentEntryScenario = es;
		outScenario.entryScenarios.add(es);
		return;
	}

	public void saveChanges() {
		String text;
		int val;
		text = this.flowValue.getText();
		try {
			val = new Integer(text);
			if (val >= 0) {
				currentEntryScenario.flow = val;
			}
		} catch (Exception e) {
			System.out.println("FLOW VALUE incorect");
		}
		for (int i = 0; i < currentEntryScenario.percentsDriverTypes.size(); i++) {
			text = this.driverTypesValue[i].getText();
			try {
				val = new Integer(text);
				if (val >= 0) {
					currentEntryScenario.percentsDriverTypes.setElementAt(new Integer(val), i);
				}
			} catch (Exception e) {
				System.out.println("DriverType " + i + " incorect value");
			}
		}
		routePanel.saveRouteValues();
	}

	public String[] getValidExits(Location entry) {
		String[] exits;
		this.validExits = new Vector<Integer>();
		Location exit;
		Route r;
		System.err.println("%1 " + outScenario.exits.size());
		System.err.println("%2 " + entry.roadIdx);
		for (int i = 0; i < this.outScenario.exits.size(); i++) {
			exit = outScenario.exits.get(i);
			for (int j = 0; j < outScenario.allRoutes.size(); j++) {
				r = outScenario.allRoutes.get(j);
				try {
					if (r.entry.equals(entry) && r.exit.equals(exit)) {
						this.validExits.add(new Integer(i));
						break;
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		System.out.println("@2 " + validExits.size());
		exits = new String[this.validExits.size()];
		for (int i = 0; i < this.validExits.size(); i++) {
			exits[i] = new String("Exit " + this.validExits.elementAt(i));
		}
		return exits;
	}

	public void disableIt() {
		this.mainConfig.setVisible(false);
	}

	public void enableIt() {
		this.mainConfig.setVisible(true);
	}
}