/************************************************************************************
 * 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.util.ArrayList;

//import vnsim.core.CarInfo;
import vnsim.map.object.*;
import vnsim.vehicular.simulator.*;





public abstract class Intersection implements java.io.Serializable {
	
	/** <code>serialVersionUID</code> */
	private static final long serialVersionUID = -5883719321862303634L;
	
	public ArrayList<DirectedRoadSegment> segments; //ordered by priority (first 2 have priority)

	public abstract void addCrossingSegment(DirectedRoadSegment drs);

	//seg1=segment on which a vehicle is
	//seg2=segment on which a vehicle intends to go

	public abstract boolean mustStop(RouteSegment seg1, RouteSegment seg2);
	public abstract boolean havePriority(RouteSegment seg1, RouteSegment seg2);
	public abstract double getMaximumSpeed(RouteSegment seg1, RouteSegment seg2);
	public abstract double getInfluenceDistance(RouteSegment seg1, RouteSegment seg2);
	public abstract double getInfluenceDistanceLaneChange(RouteSegment seg1, RouteSegment seg2);
	
	public abstract ArrayList<DirectedRoadSegment> yieldFor(RouteSegment seg1,
			RouteSegment seg2);
	
	public abstract boolean hasTrafficLights();
	
	protected boolean isOrder(int i, int j, int k) {
		//i,j,k = indices in "segments"
		//return true if segments i,j,k are in this order, in a sorting by the angle,
		//counter-clock-wise
		if (i>=segments.size()||j>=segments.size()||k>=segments.size()){
			return false;
		}
		double angle1=segments.get(i).angle;
		double angle2=segments.get(j).angle;
		double angle3=segments.get(k).angle;
		if(angle1<angle2) {
			if(angle3>angle2 || angle3<angle1)
				return true;
			else
				return false;
		} else {
			if(angle3>angle2 && angle3<angle1)
				return true;
			else 
				return false;
		}
	}

	public ArrayList<Byte> getDesiredLanes(RouteSegment src, RouteSegment dst) {

		//should return a sorted vector!
		int i=-1, j=-1;
		ArrayList<Byte> ret=new ArrayList<Byte> ();
		for(i=0;i<segments.size();i++) {
			if(segments.get(i).isSameSegment(src))
				break;
		}
		for(j=0;j<segments.size();j++) {
			if(segments.get(j).isSameSegment(dst))
				break;
		}
		if(i==segments.size() || j==segments.size()) {
			System.out.println("ERROR! getDesireLanes! RouteSegment not found in intersection!");
			
			System.out.println("SRC="+src+";DST="+dst+";INTERSECTION="+this.segments);
			ret.add((byte)1);
			return ret;
		}
		if(segments.size()>3) {
			//at least 4 segments
			
			//is there another road between src and dst (counter-clockwise) ?
			boolean isThere1=false;
			for(int k=0;k<segments.size();k++) {
				if(k==i || k==j)
					continue;
				if(isOrder(i,k,j))
					isThere1=true;
			}

			//is there another road between src and dst (clockwise) ?
			boolean isThere2=false;
			for(int k=0;k<segments.size();k++) {
				if(k==i || k==j)
					continue;
				if(isOrder(i,j,k))
					isThere2=true;
			}
			if(isThere1 && isThere2) {
				//any lane
				for(int l=1;l<=Globals.map.roads.get(src.roadIndex).laneNo;l++) {
					ret.add((byte)l);
				}
				return ret;
			}
			if(isThere1) {
				//leftmost lane
				ret.add((byte)Globals.map.roads.get(src.roadIndex).laneNo);
				return ret;
			}
			if(isThere2) {
				//rightmost lane
				ret.add((byte)1);
				return ret;
			}
			System.out.println("ERROR! getDesiredLanes - should not get here!");
			ret.add((byte)1);
			return ret;
		}
		
		if(segments.size()==3) {
			//priority road = any lane
			if((i==0 && j==1) || (i==1 && j==0)) {
				for(int l=1;l<=Globals.map.roads.get(src.roadIndex).laneNo;l++) {
					ret.add((byte)l);
				}
				return ret;
			}
			
			//is there another road between src and dst (counter-clockwise) ?
			boolean isThere1=false;
			for(int k=0;k<segments.size();k++) {
				if(k==i || k==j)
					continue;
				if(isOrder(i,k,j))
					isThere1=true;
			}
			if(isThere1) {
				//leftmost lane
				ret.add((byte)Globals.map.roads.get(src.roadIndex).laneNo);
				return ret;
			}
			//rightmost lane
			ret.add((byte)1);
			return ret;
		}
		
		//any lane
		for(int l=1;l<=Globals.map.roads.get(src.roadIndex).laneNo;l++) {
			ret.add((byte)l);
		}
		return ret;
	}

	public Point getMapPoint(){
		if (segments.size() == 0)
			return null;
		Road r = Globals.map.roads.get(segments.get(0).roadIndex);
		Point p = r.points.get(segments.get(0).pointIndex);
		return p;
	}

	public boolean equals(Object arg0) {
		Intersection x = (Intersection)arg0;
		
		if (x.segments.size() != segments.size())
			return false;
		for (int i = 0; i < segments.size(); i++){
			if (!segments.get(i).equals(x.segments.get(i))){
				return false;
			}
		}
		return true;
	}
	
	public boolean isScissors(RouteSegment src1, RouteSegment dst1, RouteSegment src2, RouteSegment dst2) {
		int i=-1, j=-1,k=-1, l=-1;
		
		for(i=0;i<segments.size();i++) {
			if(segments.get(i).isSameSegment(src1))
				break;
		}
		for(j=0;j<segments.size();j++) {
			if(segments.get(j).isSameSegment(dst1))
				break;
		}
		for(k=0;k<segments.size();k++) {
			if(segments.get(k).isSameSegment(src2))
				break;
		}
		for(l=0;l<segments.size();l++) {
			if(segments.get(l).isSameSegment(dst2))
				break;
		}
		
		if(i==-1 || j==-1 || k==-1 || l==-1)
			return false;
		
		if(isOrder(l, k, j) && isOrder(k, j, i) && isOrder(j, i, l)) {
//			System.out.println("T");
			return true;
		}
		
		if(isOrder(i,l,k) && isOrder(l,k,j) && isOrder(k,j,i)) {
//			System.out.println("T");
			return true;
		}
		
		return false;
	}

}