/************************************************************************************
 * 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.applications.adaptiveTL;


import java.lang.ref.PhantomReference;
import java.util.LinkedList;
import java.util.ListIterator;

import vnsim.applications.trafficview.SimulatedCarInfo;
import vnsim.core.*;
import vnsim.map.object.*;
import vnsim.vehicular.simulator.CarInstance;
import vnsim.vehicular.simulator.intersections.*;




public class IntersectionPath {

	Intersection intersection;
	DirectedRoadSegment roadIn;
	DirectedRoadSegment roadout;
	
	public LinkedList<IntersectionPhaseStatistics> lastHourHistory = new LinkedList<IntersectionPhaseStatistics>();
	public int analysisPeriod;
	
	public int demand, volume;
	public double avgNoOfStops;
	
	
	public IntersectionPath(Intersection intersection, DirectedRoadSegment roadIn, DirectedRoadSegment roadout){
		this.intersection = intersection;
		this.roadIn = roadIn;
		this.roadout = roadout;
		
		lastHourHistory.add(new IntersectionPhaseStatistics(0, Globals.YELLOW));
	}
	
	/**
	 * Constructor used for vector lookup
	 */
	public IntersectionPath(DirectedRoadSegment roadIn, DirectedRoadSegment roadout){
		this.roadIn = roadIn;
		this.roadout = roadout;
	}
	
	public boolean equals(Object arg0) {
		IntersectionPath ip = (IntersectionPath)arg0;
		return (this.roadIn.equals(ip.roadIn) && this.roadout.equals(ip.roadout));
	}

	public void changePhase(int crtTime, int color){
		IntersectionPhaseStatistics ips = lastHourHistory.getLast();
		ips.setPhaseEndFrame(crtTime - 1);
		if (ips.getCarsNo() != 0){
			ips.avgGap = (double)(ips.phaseEndFrame - ips.phaseStartFrame) / (Globals.SECOND * ips.carsNo);
		}
		if (roadIn.segmentIndex == 2){
			int k = 0;
			k ++;
		}
		double avg = 0;
		Point px = roadIn.road.points.get(roadIn.pointIndex);
		for (int i = 1; i < roadIn.endOfQueue.length; i++){
			if (roadIn.endOfQueue[i].car != null){
				Point p = roadIn.road.points.get(roadIn.endOfQueue[i].getCar().getPointIdx());
				avg += Math.abs(p.getDistance() - px.getDistance());
			}
		}
		avg /= roadIn.endOfQueue.length - 1;
		ips.setQueueSize((ips.getQueueSize() + avg) / 2);
		
		lastHourHistory.add((ips = new IntersectionPhaseStatistics(crtTime, color)));
		ips.setQueueSize(avg);
		IntersectionPhaseStatistics first = lastHourHistory.getFirst();
		if (crtTime - first.getPhaseEndFrame() > Globals.executionFPS * 3600){
			lastHourHistory.removeFirst();
		}
	}
	
	public void demand(IntersectionCarRecord icr){
		SimulatedCarInfo sc = icr.getCar();
		
		IntersectionPhaseStatistics ips = lastHourHistory.getLast();
		ips.demandCarsNo ++;
		if (sc.getSignal() == 1){
			ips.leftDemandCarsNo ++;
		}
	}
	
	public int computeDemand(int period){
		demand = 0;
		ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1);
		boolean skip = true;
		analysisPeriod = 0;
		while (it.hasPrevious()){
			IntersectionPhaseStatistics x = it.previous();
			if (skip){
				if (x.color == Globals.GREEN){
					skip = false;
				}else{
					continue;
				}
			}
			
			if (x.phaseEndFrame < Globals.engine.crtTime - period){
				break;
			}
			demand += x.demandCarsNo;
			analysisPeriod += x.phaseEndFrame - x.phaseStartFrame;
		}
		return demand;
	}

	public double computeLastCycleQueueSize(){
		double sum = 0;
		int count = 0;
		ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1);
		boolean first = true;
		int color = 0;
		while (it.hasPrevious()){
			IntersectionPhaseStatistics x = it.previous();
			if (!first && x.getColor() == color)
				break;
			if (first){
				first = false;
				color = x.getColor();
			}
			sum += x.queueSize * (x.phaseEndFrame - x.phaseStartFrame);
			count = x.phaseEndFrame - x.phaseStartFrame;
		}
		if (count == 0)
			return 0;
		return sum / count;
	}

	public int computeLeftDemand(int period){
		int sum = 0;
		ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1);
		while (it.hasPrevious()){
			IntersectionPhaseStatistics x = it.previous();
			if (x.phaseEndFrame < Globals.engine.crtTime - period)
					break;
			sum += x.leftDemandCarsNo;
		}
		return sum;
	}
	
	public int computeVolume(int period){
		int sum = 0;
		ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1);
		analysisPeriod = 0;
		while (it.hasPrevious()){
			IntersectionPhaseStatistics x = it.previous();
			if (x.phaseEndFrame < Globals.engine.crtTime - period)
				break;
			sum += x.carsNo;
			analysisPeriod += x.phaseEndFrame - x.phaseStartFrame;
		}
		return sum;
	}

	public double computeAvgNoOfStops(int period){
		int sum = 0;
		double no = 0;
		ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1);
			
		while (it.hasPrevious()){
			IntersectionPhaseStatistics x = it.previous();
			if (x.phaseEndFrame < Globals.engine.crtTime - period)
				break;
			sum += x.carsNo;
			no += x.carsNo * x.avgNoOfStops;
		}
		if (sum == 0)
			return 0;
		else
			return (double)no/sum;
	}
	
	public void recordCar(IntersectionCarRecord icr){
		SimulatedCarInfo sc = icr.getCar();
		
		IntersectionPhaseStatistics ips = lastHourHistory.getLast();
		int idx = lastHourHistory.size() - 1;
		
		if (sc.getTimestamp() < ips.phaseStartFrame ){
			idx -- ;
			ips = lastHourHistory.get(idx);
		}
		
// compute number of cars
		int reds = 0;
		if (icr.getQueuedTime() == -1){
			reds = 0;
		}else{
			if (ips.phaseStartFrame > icr.getQueuedTime()){
				ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(idx);
				while (it.hasPrevious()){
					IntersectionPhaseStatistics x = it.previous();
					if (x.phaseEndFrame < icr.getQueuedTime())
						break;
					if (x.getColor() == Globals.RED)
						reds ++;
				}
			}
		}
		
		//compute delay at the simulation layer
		Road r = Globals.map.roads.get(roadout.roadIndex);
		CarInstance ci = new CarInstance((short)roadout.roadIndex, (short)roadout.pointIndex, null);
		ci.ID = icr.getCar().getVehicleId();
		ci = r.carsOnThisRoad.get(ci, roadout.direction);
		if (ci != null)
			ips.avgControlDelay = (int)((double)(ips.avgControlDelay * ips.carsNo + ci.controlDelay )/ (ips.carsNo + 1));
		
		ips.avgSpeed = (ips.avgSpeed * ips.carsNo + sc.getSpeed() )/ (ips.carsNo + 1) ;
			
		ips.avgNoOfStops = (double)(ips.getAvgNoOfStops() * ips.carsNo + reds )/ (ips.carsNo + 1);
		
		ips.carsNo ++;
	}
	
	public IntersectionPhaseStatistics getLastGreenPhase(){
		ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1);
		while (it.hasPrevious()){
			IntersectionPhaseStatistics x = it.previous();
			if (x.phaseEndFrame != -1 && x.color == Globals.GREEN){
				return x;
			}
		}
		return null;
	}
	
}