/************************************************************************************
 * 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.vehicular.simulator.intersections;

import java.io.File;
import java.util.ArrayList;

import vnsim.map.object.Globals;
import vnsim.vehicular.simulator.*;

public class IntersectionWithTrafficLights extends Intersection {

	/** <code>serialVersionUID</code> */
	private static final long serialVersionUID = -5883719321862303634L;

	// indices corresponding with the "segments" Vector
	// public ArrayList<TrafficLightInfo> lightInfos;
	public ArrayList<Integer> currentColor; // 1=RED, 2=YELLOW, 3=GREEN

	public int lastCycleStartTime = 0;
	public int cycleLength;

	public void addCrossingSegment(DirectedRoadSegment drs) {
		if (segments == null) {
			segments = new ArrayList<DirectedRoadSegment>();
			currentColor = new ArrayList<Integer>();
		}
		if (!segments.contains(drs)) {
			segments.add(drs);
			currentColor.add(0);
		}
	}

	// public void addTrafficLightInfo(TrafficLightInfo info) {
	// if(lightInfos==null) {
	// lightInfos=new ArrayList<TrafficLightInfo> ();
	// }
	// lightInfos.add(info);
	// }

	public synchronized boolean isGreen(RouteSegment src) {
		for (int i = 0; i < segments.size(); i++) {
			if (segments.get(i).isSameSegment(src)) {
				if (currentColor.get(i).intValue() == 3)
					return true;
				else
					return false;
			}
		}
		System.err.println("ERROR! isGreen called, but segment not found in intersection!");
		System.err.println("->"+src.roadIndex+" "+src.pt1+" "+src.pt2);
		for (int i = 0; i < segments.size(); i++) {
			System.err.println("\t->"+segments.get(i).roadIndex+" "+segments.get(i).pointIndex);	
		}
		return false;
	}

	public synchronized boolean isGreen(int k) {
		if (currentColor.get(k).intValue() == 3)
			return true;
		return false;
	}

	public synchronized boolean isRed(int k) {
		if (currentColor.get(k).intValue() == 1)
			return true;
		return false;
	}

	public synchronized boolean isYellow(RouteSegment src) {
		for (int i = 0; i < segments.size(); i++) {
			if (segments.get(i).isSameSegment(src)) {
				if (currentColor.get(i).intValue() == 2)
					return true;
				else
					return false;
			}
		}
		System.out.println("ERROR! isYellow called, but segment not found in intersection!");
		return false;
	}

	public boolean mustStop(RouteSegment src, RouteSegment dst) {
		return false;
	}

	public boolean havePriority(RouteSegment seg1, RouteSegment seg2) {
		return false;
	}

	public synchronized ArrayList<DirectedRoadSegment> yieldFor(RouteSegment seg1, RouteSegment seg2) {
		// a vehicle coming on "seg1", going on "seg2"
		// must yield to vehicles coming on which segments?
		ArrayList<DirectedRoadSegment> ret = new ArrayList<DirectedRoadSegment>();
		int i;
		for (i = 0; i < segments.size(); i++) {
			if (segments.get(i).isSameSegment(seg1))
				break;
		}
		int j;
		for (j = 0; j < segments.size(); j++) {
			if (segments.get(j).isSameSegment(seg2))
				break;
		}
		if (i == segments.size() || j == segments.size())
			System.out.println("*** ERROR! yieldFor - wrong parameters!");
		for (int k = 0; k < segments.size(); k++) {
			if (k == i || k == j)
				continue;
			if (isOrder(i, k, j) && isGreen(k)) {
				ret.add(segments.get(k));
			}
		}
		return ret;
	}

	public boolean isLeftTurn(RouteSegment seg1, RouteSegment seg2) {
		DirectedRoadSegment s1 = null, s2 = null;
		int i;
		for (i = 0; i < segments.size(); i++) {
			if (segments.get(i).isSameSegment(seg1)) {
				s1 = segments.get(i);
				break;
			}
		}
		int j;
		for (j = 0; j < segments.size(); j++) {
			if (segments.get(j).isSameSegment(seg2)) {
				s2 = segments.get(j);
				break;
			}
		}
		if (s1 != null && s1.left != null && s1.left.equals(s2))
			return true;
		return false;
	}

	// returns the maximum allowed speed when the light is green
	public double getMaximumSpeed(RouteSegment seg1, RouteSegment seg2) {
		return 20.0;
	}

	public double getInfluenceDistance(RouteSegment seg1, RouteSegment seg2) {
		return 0.100;
	}

	public double getInfluenceDistanceLaneChange(RouteSegment seg1, RouteSegment seg2) {
		return 0.200;
	}

	public boolean hasTrafficLights() {
		return true;
	}

	public String toString() {
		String ret = "";
		ret = ret + segments + " - " + currentColor;
		return ret;
	}

	public void step(int crtTime) {

		int thisSec = (int) (crtTime / (Globals.executionFPS));
		int prevSec = (int) ((crtTime - 1) / (Globals.executionFPS));
		int aux = thisSec % this.cycleLength;
		int prev = prevSec % this.cycleLength;

		synchronized (this) {
			this.currentColor = new ArrayList<Integer>();
			for (int k = 0; k < this.segments.size(); k++) {
				TrafficLightInfo info = segments.get(k).lightInfo;
				int color = info.getColor(aux);
				this.currentColor.add(new Integer(color));
				if (info.getColor(prev) != color) {
					segments.get(k).changePhase(null, crtTime, color);
				}
			}
		}
	}

}