package com.guru.project.shortestPath.dijkstra
{
	
	//import __AS3__.vec.Vector;
	
	//import structs.graphs.Dijkstra;
	//import structs.graphs.Graph;
	//import structs.graphs.Vertex;
	
	import com.guru.call.ICall;
	import com.guru.project.shortestPath.dijkstra.dijkstra.GEdge;
	import com.guru.project.shortestPath.dijkstra.dijkstra.GVertex;
	import com.guru.project.shortestPath.dijkstra.dijkstra.structs.graphs.Dijkstra;
	import com.guru.project.shortestPath.dijkstra.dijkstra.structs.graphs.Graph;
	import com.guru.project.shortestPath.dijkstra.dijkstra.structs.graphs.Vertex;
	import com.guru.project.shortestPath.dijkstra.dijkstra.TextControls;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.utils.getTimer;
	
	public class PathManager
	{

		private var mGraph:Graph;
		private var mVertices_array:Array;
		private var mEdges:GEdge;
		private var mItems:uint;
		private var mSrc:Vertex;
		private var mDst:Vertex;
		//private var mText:TextControls;
		private var mTime:Number;
		private var mNode_array:Array;
		private var mEdge_array:Array;
		private var mPath_array:Array;
		private var mShortestNodeId_array:Array;
		
		public function PathManager()
		{
			
		}
		
		public function dispose():void
		{
			
		}
		
		public function setNode(pNode_array:Array):void
		{
			mNode_array = pNode_array;
		}
		
		public function setEdge(pEdge_array:Array):void
		{
			mEdge_array = pEdge_array;
		}
		
		public function getShortestNodeId():Array
		{
			return mShortestNodeId_array;
		}
		
		public function getShortestPath():Array
		{
			return mPath_array;
		}
		
		public function init():void
		{
			mGraph = new Graph();
			mEdges = new GEdge();
			
			mVertices_array = new Array();
			mItems = 0;
			
			var vertex:GVertex;
			var edge:GEdge;
			
			for ( var i:int = 0; i < mNode_array.length; i++ )
			{
				vertex = new GVertex( "v" + i );
				vertex.x = mNode_array[ i ][ 0 ];
				vertex.y = mNode_array[ i ][ 1 ];
				mVertices_array.push( vertex );
				mGraph.addVertex( new Vertex( "v" + i ) );
			}
			
			for ( i = 0; i < mEdge_array.length; i++ )
			{
				var start:GVertex = mVertices_array[ mEdge_array[ i ][ 0 ] ];
				var end:GVertex = mVertices_array[ mEdge_array[ i ][ 1 ] ];
				var distance_num:Number = Math.sqrt(Math.pow(start.y - end.y, 2) + Math.pow(start.x - end.x, 2));
				var w:int = distance_num; 
				if (i == mEdge_array.length - 1)
					w = 5;
				
				w = 5;	
				
				mEdges.connect( mVertices_array[ mEdge_array[ i ][ 0 ] ], mVertices_array[ mEdge_array[ i ][ 1 ] ], w );
				mGraph.addEdge( mGraph.vertices.getNode( mEdge_array[ i ][ 0 ] ).data, 
								mGraph.vertices.getNode( mEdge_array[ i ][ 1 ] ).data, w );
			}
		}
		
		public function selectVertex(pFromNodeIndex_num:Number, pToNodeIndex_num:Number):void
		{
			mEdges.reset();
			reset();
			
			mSrc = mGraph.vertices.getNode(pFromNodeIndex_num).data;
			mDst = mGraph.vertices.getNode(pToNodeIndex_num).data;
			
			getPath();
			
		}
		
		private function reset():void
		{
			for ( var i:int = 0; i < mVertices_array.length; ++i )
			{
				GVertex(mVertices_array[ i ]).selected = false;
				GVertex(mVertices_array[ i ]).marked = false;
				GVertex(mVertices_array[ i ]).render();
			}
			mItems = 0;	
		}
		
		private function getPath():void
		{
			mShortestNodeId_array = new Array();
			mPath_array = new Array();
			mTime = getTimer();
			var d:Dijkstra = new Dijkstra( mGraph, mSrc, mDst );
			var res:Vertex = d.search();
			var w:int = res.weight;
			
			var path_str:String = "";
			
			while ( res )
			{
				if ( res.parent )
				{
					var rid:int = int( res.name.split( "v" )[ 1 ] );
					var pid:int = int( res.parent.name.split( "v" )[ 1 ] );
					GVertex(mVertices_array[ rid ]).selected = true;
					GVertex(mVertices_array[ rid ]).render();
					GVertex(mVertices_array[ pid ]).selected = true;
					GVertex(mVertices_array[ pid ]).render();
					mPath_array.unshift(GVertex(mVertices_array[ rid ]));
					mShortestNodeId_array.unshift(rid);
					path_str = rid + ", " + path_str;
					mEdges.connect( GVertex(mVertices_array[ rid ]), GVertex(mVertices_array[ pid ]), 0, true );
				}
				res = res.parent;
			}
			
			//trace("shortest path: " + path_str);
		}

	}
	
}