package vnsim.socialNet;

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

import vnsim.map.object.Globals;
import vnsim.map.object.Map;
import vnsim.map.object.Point;
import vnsim.map.object.Road;
import vnsim.vehicular.scenarios.Route;
import vnsim.vehicular.routePlan.*;

public class Util {
	
	public static void getCellSize(String nume){
		try {
			
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream(System.getProperty("user.home") + File.separatorChar + "maps" + 
					File.separatorChar + "map" + File.separatorChar + nume));

			Map currentMap=(vnsim.map.object.Map)ois.readObject();
			Globals.map = currentMap;

			Point tmpPoint, minPoint, maxPoint;
			Road tmpRoad;
			int i, j;
			i = 0;
			//currentMap = Globals.map;

			minPoint = new Point((double) 180, (double) 90);
			maxPoint = new Point((double) -180, (double) -90);
			while (i < currentMap.roads.size()) {
				tmpRoad = (Road) currentMap.roads.get(i);
				j = 0;
				while (j < tmpRoad.points.size()) {// for evey points from the selected road
					tmpPoint = (Point) tmpRoad.points.get(j);
					if (tmpPoint.getLatitude() < minPoint.getLatitude()) {
						minPoint.setLatitude(tmpPoint.getLatitude());
					}
					if (tmpPoint.getLongitude() < minPoint.getLongitude()) {
						minPoint.setLongitude(tmpPoint.getLongitude());
					}

					if (tmpPoint.getLatitude() > maxPoint.getLatitude()) {
						maxPoint.setLatitude(tmpPoint.getLatitude());
					}
					if (tmpPoint.getLongitude() > maxPoint.getLongitude()) {
						maxPoint.setLongitude(tmpPoint.getLongitude());
					}

					j++;
				}
				i++;
			}
			//System.out.println("Pct maxim ( "+maxPoint.getLatitude()+" "+maxPoint.getLongitude()+" )");
			//System.out.println("Pct min ( "+minPoint.getLatitude()+" "+minPoint.getLongitude()+" )");

			GlobalNetwork.pointMax = maxPoint;
			GlobalNetwork.pointMin = minPoint;
			
			ois.close();
		} catch (Exception ex) {
			ex.printStackTrace();
			//throw ex;
		}
	}
	
	public static boolean intersecRoad(CellInformation ci){
		Map currentMap = Globals.map;
		Point tmpPoint;
		Road tmpRoad;
		int i, j;
		boolean gasit = false;
		i = 0;
		while (i < currentMap.roads.size()) {
			tmpRoad = (Road) currentMap.roads.get(i);
			j = 0;
			while (j < tmpRoad.points.size()){
				tmpPoint = (Point) tmpRoad.points.get(j);
				if((ci.pointMin.getLatitude()<tmpPoint.getLatitude())&&(tmpPoint.getLatitude()<ci.pointMax.getLatitude())){
					if((ci.pointMin.getLongitude()<tmpPoint.getLongitude())&&(tmpPoint.getLongitude()<ci.pointMax.getLongitude())){
						ci.addValidPoint(tmpPoint);
						ci.addValidLocation(i, j);
						gasit = true;
					}
				}
				j++;
			}
			i++;
		}
		return gasit;
	}
	
	public static boolean isInGroup(int i,int group[],int members){
		boolean result=false;
		
		for (int k=0;k<members;k++)	
			if (group[k]==i) {
				result=true;
			}
	 	return result;
	}
	
	public static boolean areInAGroup(int i,int j,int groups[][],int nrGroups,int numberOfMembers[]){
		
		boolean result=false;
		
		for (int k=0;k<nrGroups;k++) {
			
			if (isInGroup(i,groups[k],numberOfMembers[k]))
				if (isInGroup(j,groups[k],numberOfMembers[k])) {
					result=true;
				}
			}
		
		return result;
	}

	public static void assign_distance(double distance[], int d, int assigned[], ArrayList<NodeInformation> ni, int pred[][], int predNum[], int nrHosts) {
	 			
	 			for (int k=0;k<nrHosts; k++)
		 			if (distance[k]==d) {
						for (int r=0;r<nrHosts;r++)	  			
		 					if (ni.get(k).getAdjacency(r)==1) 
		 						if (assigned[r]==1) {
		 							distance[r]=d+1;
		 							assigned[r]=0;
		 							boolean found=false;
		 							for (int p=0;p<predNum[r]; p++) 
		 								if (pred[r][p]==k) found=true;
		 							if (found==false) {
		 								pred[r][predNum[r]]=k;
		 								predNum[r]=predNum[r]+1;
		 							}
		 						}	
		 			}
	 		
	}	

	public static void calculate_b (double betw[], double distance[], int pred[][], int predNum[], int nrHosts) {
		
		for (int dist=15;dist>-1;dist--) 
			
			for (int k=0; k<nrHosts; k++)
				if (distance[k]==dist) {
					for (int i=0; i<predNum[k]; i++) {
						betw[pred[k][i]]=betw[pred[k][i]]+betw[k]/predNum[k];
					}
			
				}
	}
	
	public static void calculate_betweenness(double res_betw[],ArrayList<NodeInformation> ni,int nrHosts){

		double distance[]= new double[nrHosts];
		int assigned[]= new int[nrHosts];
		int predNum[]= new int[nrHosts];
		double betw[]= new double[nrHosts];
		double current_betw[]=new double[nrHosts];
		
		for (int i=0; i<nrHosts;i++) { 
			assigned[i]=1;
			distance[i]=15;
			betw[i]=1;
			current_betw[i]=0;		
		}
			
		int pred[][]= new int[nrHosts][nrHosts];
			
		for (int i=0; i<nrHosts; i++) {
				for (int s=0; s<nrHosts;s++) { 
							assigned[s]=1;
							distance[s]=16;
							predNum[s]=0;
							betw[s]=1;
				}

				assigned[i]=0;
				distance[i]=0;
				for (int d=0;d<15;d++) 
					assign_distance(distance,d,assigned,ni,pred,predNum,nrHosts);			 					
			
				calculate_b(betw, distance, pred, predNum,nrHosts); 		
			
				for (int z=0;z<nrHosts;z++) {
					current_betw[z]=current_betw[z]+betw[z];
				}		
		}

		for (int z=0;z<nrHosts;z++)		
			res_betw[z]=current_betw[z];		

	}
	
	public static void assignToAGroup (int current, int currentGroup, ArrayList<NodeInformation> ni, ArrayList<Integer> groups,int nrHosts,boolean assigned[]) {
		
		for (int k=0;k<nrHosts;k++) 
			
			if (ni.get(current).getAdjacency(k)==1) 
				if (current!=k)
					if (assigned[k]==false) {
						groups.add(k+1);
						assigned[k]=true;
						assignToAGroup(k,currentGroup,ni, groups, nrHosts, assigned);	
					}
	}
	
	public static int getGroups(ArrayList<NodeInformation> ni,ArrayList<ArrayList<Integer>>  groups, int nrHosts) {
		
		int numberOfGroups=0;
		boolean assigned[] = new boolean[nrHosts];
		
		for (int i=0; i<nrHosts; i++) {
			assigned[i]=false;	
		} 

		for (int i=0; i<nrHosts; i++) {
			
			if (assigned[i]==false) {
				numberOfGroups++;
				ArrayList<Integer> aux = new ArrayList<Integer>();
				aux.add(new Integer(i+1));
				assigned[i]=true;
				assignToAGroup(i,numberOfGroups,ni, aux, nrHosts, assigned);
				groups.add(aux);
			}			
		}
		return numberOfGroups;
	}
	
	public static boolean inGroup(int i,ArrayList<Integer> group){
		boolean result=false;
		
		for (int k=0;k<group.size();k++)	
			if (group.get(k).intValue()==i) {
				result=true;
			}
	 	return result;
	}
	
	public static boolean areInSameGroup(int i,int j,ArrayList<ArrayList<Integer>> groups,int nrGroups){
		
		boolean result=false;
		
		for (int k=0;k<nrGroups;k++) {
			
			if (inGroup(i,groups.get(k)))
				if (inGroup(j,groups.get(k))) {
					result=true;
				}
			}
		
		return result;
	}
	
	public static void splitNetwork (ArrayList<NodeInformation> ni, double betw[],int nrHosts) { 

		int best=0;
		double bestBetw=0;
		
		double betw2[] = new double[nrHosts];
		
		for (int i=0;i<nrHosts;i++) {
			if (betw[i]>bestBetw) { 
				bestBetw=betw[i];
				best=i;	
			}	
		}

		double minBetw=bestBetw;
		int linkToDelete=0;
		for (int i=0;i<nrHosts;i++) {
			if ((ni.get(best).getAdjacency(i)==1)&&(best!=i)){
				ni.get(best).setAdjacency(i, 0);
				ni.get(i).setAdjacency(best, 0);	
				calculate_betweenness(betw2, ni, nrHosts);
				if (betw2[best]<minBetw) {
					minBetw=betw2[best];
					linkToDelete=i;
				}	
				ni.get(best).setAdjacency(i, 1);
				ni.get(i).setAdjacency(best, 1);	
						
			}
		}

		ni.get(best).setAdjacency(linkToDelete, 0);
		ni.get(linkToDelete).setAdjacency(best, 0);

	}

	
	public static double splitNetwork_Threshold (ArrayList<NodeInformation> ni, double betw[], int nrHosts, double modThreshold) {

		int numberOfGroups_after=0;
		double numberOfLinks_before=0;

		ArrayList<ArrayList<Integer>> groups_before= new ArrayList<ArrayList<Integer>>();
		ArrayList<ArrayList<Integer>> groups_after= new ArrayList<ArrayList<Integer>>();
		
		double totalResults[][]= new double[nrHosts][nrHosts];
		int adjacency_before[][]= new int[nrHosts][nrHosts];	
		
		for (int i=0;i<nrHosts;i++)
			for (int j=0;j<nrHosts;j++) {
				adjacency_before[i][j]=ni.get(i).getAdjacency(j);
			}
		 
		getGroups(ni, groups_before,nrHosts);
		
		splitNetwork(ni, betw, nrHosts); 
		
		numberOfGroups_after=getGroups(ni, groups_after ,nrHosts);
		
		double modularity[][]= new double[nrHosts][nrHosts];
		double modularity_num[][]= new double[nrHosts][nrHosts];
		
		for (int i=0;i<numberOfGroups_after;i++) 
			for (int j=0;j<numberOfGroups_after;j++) {
				modularity_num[i][j]=0;		
			}
			
		for (int i=0;i<nrHosts;i++){
			for (int j=0;j<nrHosts;j++) {
				if (adjacency_before[i][j]==1){
					numberOfLinks_before=numberOfLinks_before+1;	
				}
			}
		}


		for (int i=0;i<nrHosts;i++) 
			for (int j=0;j<nrHosts;j++) {
				if (adjacency_before[i][j]==1)  {
					for (int g1=0;g1<numberOfGroups_after;g1++) {
						if (inGroup(i+1,groups_after.get(g1))) {
							for (int g2=0;g2<numberOfGroups_after;g2++)
								if (inGroup(j+1,groups_after.get(g2))) {
									modularity_num[g1][g2]=modularity_num[g1][g2]+1;
								}
						}
					}
				}
		}		
		
		for (int i=0;i<numberOfGroups_after;i++) 
			for (int j=0;j<numberOfGroups_after;j++) {
				modularity[i][j]=modularity_num[i][j]/numberOfLinks_before;		
			}

		double total1=0;   
		for (int i=0;i<numberOfGroups_after;i++)
			total1=total1+modularity[i][i];
	  
		for (int i=0;i<numberOfGroups_after;i++) {
			for (int j=0;j<numberOfGroups_after;j++) {
					double partial=0;
					for (int t=0;t<numberOfGroups_after;t++)
						partial=partial+modularity[i][t]*modularity[t][j];
					totalResults[i][j] = partial;
			}
		}	  
	  
		double total2=0;
	   for (int i=0;i<numberOfGroups_after;i++)
	   	for (int j=0;j<numberOfGroups_after;j++)
	   		total2=total2+totalResults[i][j];
	 
	   double q=total1-total2;

	   if (numberOfGroups_after==nrHosts) {
		   return -1;	
		}	
		
		if (q>modThreshold) {
			return q;
		
		}

		else {
			for (int i=0;i<nrHosts;i++)
				for (int j=0;j<nrHosts;j++) {
					ni.get(i).setAdjacency(j, adjacency_before[i][j]);
			}
			return -1;
		}
		
	}

}