/************************************************************************************
 * 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.Collections;
import java.util.Comparator;
import java.util.Random;
import java.util.ArrayList;

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



public class IntersectionWithoutTrafficLights extends Intersection {
	
	/** <code>serialVersionUID</code> */
	private static final long serialVersionUID = -5883719321862303634L;

	public ArrayList<Boolean> mustStop; //indices corresponding with "segments" = must stop or not

	public IntersectionWithoutTrafficLights() {
	}

	public void addCrossingSegment(DirectedRoadSegment drs) {
		if(segments==null) {
			segments=new ArrayList<DirectedRoadSegment> ();
			mustStop=new ArrayList<Boolean> ();
		}
		if(!segments.contains(drs)) {
			segments.add(drs);
			mustStop.add(true);
		}
	}

	public boolean mustStop(RouteSegment seg1, RouteSegment seg2) {
		for(int i=0;i<segments.size();i++) {
			if(segments.get(i).isSameSegment(seg1))
				return mustStop.get(i);
		}
		System.out.println("ERROR! mustStop called, but segment not found in that intersection!");
		System.out.println("Segment called: "+seg1+"; MY SEGS="+segments);
		return false;
	}

	public boolean havePriority(RouteSegment seg1, RouteSegment seg2){
		//have absolute priority? (yield to nobody)
		//look through "segments"; the first 2 have priority
		if((segments.get(0).isSameSegment(seg1)) && (segments.get(1).isSameSegment(seg2)))
			return true;
		if((segments.get(0).isSameSegment(seg2)) && (segments.get(1).isSameSegment(seg1)))
			return true;
		return false;
	}

	public double getMaximumSpeed(RouteSegment seg1, RouteSegment seg2) {
		//look through "segments"
		if(havePriority(seg1, seg2))
			return 40.0; //speed adjustment
		if(mustStop(seg1, seg2))
			return 0.0;
		return 20.0;
	}

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

	public ArrayList<DirectedRoadSegment> yieldFor(RouteSegment seg1,
			RouteSegment seg2) {
		//a vehicle coming on "seg1", going on "seg2"
		//must yield to vehicles coming on which segments?

		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!");
		//priority
		if((i==0 && j==1) || (i==1 && j==0))
			return new ArrayList<DirectedRoadSegment>(); 

		if(i==0 || i==1) {
			//yield to the other priority road, and only if going on "seg2"
			//means crossing it (to the left)
			if(i==0) {
				if(isOrder(0,1,j)) {
					ArrayList<DirectedRoadSegment> ret=new ArrayList<DirectedRoadSegment> ();
					ret.add(segments.get(1));
					return ret;
				} else
					return new ArrayList<DirectedRoadSegment> ();
			}
			if(i==1) {
				if(isOrder(1,0,j)) {
					ArrayList<DirectedRoadSegment> ret=new ArrayList<DirectedRoadSegment> ();
					ret.add(segments.get(0));
					return ret;
				} else
					return new ArrayList<DirectedRoadSegment> ();
			}
		}

		//I have an "yield" sign
		ArrayList<DirectedRoadSegment> ret=new ArrayList<DirectedRoadSegment> ();

		//I must yield to all roads which are between "seg1" and "seg2" 
		//(counter-clock-wise);
		//Furthermore, if one of the priority roads is between "seg1" and "seg2", including "seg2",
		//then I must also yield to the other priority road!
		for(int k=0;k<segments.size();k++) {
			if(k==1 && ret.contains(segments.get(1)))
				continue;
			if(k!=j) {
				if(isOrder(i,k,j)) {
					ret.add(segments.get(k));
					if(k==0) {
						ret.add(segments.get(1));
					}
					if(k==1) {
						if(!ret.contains(segments.get(0)))
							ret.add(segments.get(0));
					}
				}
			}
		}

		if(j==1) {
			//yield to 0
			if(!ret.contains(segments.get(0)))
				ret.add(segments.get(0));
		}
		if(j==0) {
			//yield to 1
			if(!ret.contains(segments.get(1)))
				ret.add(segments.get(1));
		}
		return ret;
	}

	public boolean hasTrafficLights() {
		return false;
	}

	public void sort(Random generator){
		Collections.sort(this.segments,new Comparator<DirectedRoadSegment>(){
			public int compare(DirectedRoadSegment s1,DirectedRoadSegment s2){
				int r1,r2,p1,p2;
				//System.out.println("COMPAR: "+s1+" CU "+s2);
				r1=s1.roadIndex;
				r2=s2.roadIndex;				
				byte b1[];
				byte b2[];
				
				b1=Globals.map.roads.get(r1).getRoadinfo();
				b2=Globals.map.roads.get(r2).getRoadinfo();
				if(b1[1]<b2[1]){
					return -1;
				}else{
					if(b1[1]>b2[1]){
						return 1;
					}else{
						p1=Globals.map.roads.get(r1).getPoints().size();
						p2=Globals.map.roads.get(r2).getPoints().size();
						if(p1>p2){
							return -1;
						} else {
							if(p1<p2){
								return 1;
							}else{
								return 0;
							}
						}
					}
				}
			}
		});
		//System.out.println("Sort over1");

		this.mustStop=new ArrayList<Boolean>();
		this.mustStop.add(false);
		this.mustStop.add(false);

		for(int ll=2;ll<this.segments.size();ll++){
			this.mustStop.add(generator.nextBoolean());
		}
		//System.out.println("Sort over2");
	}

	public String toString() {
		String ret="";
		ret=ret+"Segs:"+segments+";MustStop="+mustStop;
		return ret;
	}
}