<?php
global $GANGLIA_PATH, $clustername, $tpl, $filter, $cluster, $get_metric_string, $cluster_url, $sh;
global $hosts_up, $m, $start, $end;

$data_gatherer = new DataGatherer();

//$tpl->assign( "self", "./index.php" );
$tpl->assign( "clustername", $clustername );

$data_gatherer->parseXML();

$heartbeat = $data_gatherer->getHeartbeat();
$jobs = $data_gatherer->getJobs();
$gnodes = $data_gatherer->getNodes();
$cpus = $data_gatherer->getCpus();

$filter_image_url = "";

foreach( $filter as $filtername => $filtervalue ) {
	$tpl->assign( "f_".$filtername, $filtervalue );
	$filter_image_url .= "&$filtername=$filtervalue";
}

$tpl->assign( "clusterimage", "./image.php?c=".rawurlencode($clustername)."&view=big-clusterimage".$filter_image_url );

if( array_key_exists( "id", $filter ) )
	$pie = drawJobPie();
else if( array_key_exists( "user", $filter ) )
	$pie = drawUserPie();
else if( array_key_exists( "queue", $filter ) )
	$pie = drawQueuePie();
else
	$pie = drawClusterPie();

$tpl->assign("pie", $pie );

//if( !array_key_exists( 'id', $filter ) ) {

//	$graph_args = "c=$cluster_url&$get_metric_string&st=$cluster[LOCALTIME]";
//	$tpl->newBlock( "average_graphs" );
//	$tpl->assign( "graph_args", $graph_args );
//}

function timeToEpoch( $time ) {

	$time_fields = explode( ':', $time );

	if( count($time_fields) == 3 ) {

		$hours = $time_fields[0];
		$minutes = $time_fields[1];
		$seconds = $time_fields[2];

		$myepoch = intval( $seconds + (intval( $minutes * 60 )) + (intval( $hours * 3600 )) );
		return $myepoch;
	}
}

function makeTime( $time ) {

	$days = intval( $time / 86400 );
	$time = $days ? $time % ($days * 86400) : $time;

	if( $days > 0 ) {
		if( $days > 1 )
			$date_str .= $days . ' days - ';
		else
			$date_str .= $days . ' day - ';
	}

	$hours = intval( $time / 3600 );
	$time = $hours ? $time % ($hours * 3600) : $time;

	if( $hours > 0 ) {
		$date_str .= $hours . ':';
		$date_unit = ' hours';
	}
		
	$minutes = intval( $time / 60 );
	$seconds = $minutes ? $time % ($minutes * 60) : $time;

	if( $minutes > 0 ) {

		if( $minutes >= 10 )
			$date_str .= $minutes . ':';
		else
			$date_str .= '0' . $minutes . ':';

		$date_unit = (!isset($date_unit)) ? 'minutes' : $date_unit;
	} else if( $days > 0 or $hours > 0 ) {
		$date_str .= '00:';
		$date_unit = (!isset($date_unit)) ? 'minutes' : $date_unit;
	}

	$date_unit = (!isset($date_unit)) ? 'seconds' : $date_unit;

	if( $seconds > 0 ) {

		if( $seconds >= 10 )
			$date_str .= $seconds . ' ' . $date_unit;
		else
			$date_str .= '0' . $seconds . ' ' . $date_unit;
			
	} else if ( $days > 0 or $hours > 0 or $minutes > 0 )
		$date_str .= '00 ' . $date_unit;

	return $date_str;
}

function makeDate( $time ) {
	return strftime( "%a %d %b %Y %H:%M:%S", $time );
}

function colorRed( $color ) {
	return substr( $color, 0, 2 );
}
function colorGreen( $color ) {
	return substr( $color, 2, 2 );
}
function colorBlue( $color ) {
	return substr( $color, 4, 2 );
}

function colorDiffer( $first, $second ) {

	// Make sure these two colors differ atleast 50 R/G/B
	$min_diff = 50;

	$c1r = decHex( colorRed( $first ) );
	$c1g = decHex( colorGreen( $first ) );
	$c1b = decHex( colorBlue( $first ) );

	$c2r = decHex( colorRed( $second ) );
	$c2g = decHex( colorGreen( $second ) );
	$c2b = decHex( colorBlue( $second ) );

	$rdiff = ($c1r >= $c2r) ? $c1r - $c2r : $c2r - $c1r;
	$gdiff = ($c1g >= $c2g) ? $c1g - $c2g : $c2g - $c1g;
	$bdiff = ($c1b >= $c2b) ? $c1b - $c2b : $c2b - $c1b;

	if( $rdiff >= $min_diff or $gdiff >= $min_diff or $bdiff >= $min_diff )
		return TRUE;
	else
		return FALSE;
}

function randomColor( $known_colors ) {

	$start = hexdec( "004E00" );
	$end = hexdec( "FFFFFF" );

	if( count( $known_colors ) == 0 )
		return dechex(rand( $start, $end ));

	$color_changed = TRUE;

	while( $color_changed ) {

		$color_changed = FALSE;

		foreach( $known_colors as $old ) {

			if( !isset( $new ) )
				$new = rand( $start, $end );

			if( !colorDiffer( dechex( $new ), $old ) )

				while( !colorDiffer( $new, $old ) ) {

					$new = rand( $start, $end );
					$color_changed = TRUE;
				}
		}
	}

	// Whoa! Actually found a good color ;)
	return dechex( $new );
}

function drawJobPie() {
}

function drawUserPie() {

}

function drawQueuePie() {

}


function drawClusterPie() {

	global $jobs, $gnodes;

	$nodes = $gnodes;
	
	$pie_args = "title=" . rawurlencode("Cluster queue usage");
	$pie_args .= "&size=250x150";

	$queues = array();
	$nr_jobs = count( $jobs );
	$nr_nodes = count( $nodes );

	$emptynodes = 0;

	$job_weight = array();

	foreach( $nodes as $node ) {

		$myjobs = $node->getJobs();

		if( count( $myjobs ) == 0 )
			$emptynodes++;
	}
	$used_nodes = $nr_nodes - $emptynodes;

	$empty_percentage = ($emptynodes / $nr_nodes) * 100;
	$job_percentage = 100 - $empty_percentage; 

	$color = randomColor( $qcolors );
	$qcolors[] = $color;
	$pie_args .= "&free=$empty_percentage,$color";

	foreach( $nodes as $node ) {

		$node_jobs = $node->getJobs();
		$nr_node_jobs = count( $node_jobs );
		$myhost = $node->getHostname();

		foreach( $node_jobs as $myjob ) {

			// Determine the weight of this job on the node it is running
			// - what percentage of the node is in use by this job
			//
			$job_weight[$myjob] = ( 100 / count( $node_jobs ) ) / 100;
			$qname = $jobs[$myjob][queue];

			if( !isset( $queues[$qname] ) )
				$queues[$qname] = $job_weight[$myjob];
			else
				$queues[$qname] = $queues[$qname] + $job_weight[$myjob];
		}
	}

	$qcolors = array();
	foreach( $queues as $queue => $totalweight) {

		$percentage = ( $totalweight / $used_nodes ) * $job_percentage;
		
		$color = randomColor( $qcolors );
		$qcolors[] = $color;
		$pie_args .= "&$queue=$percentage,$color";
	}
	$pie = "../../pie.php?$pie_args";

	return $pie;
}


function sortJobs( $jobs, $sortby, $sortorder ) {

	$sorted = array();

	$cmp = create_function( '$a, $b', 
		"global \$sortby, \$sortorder;".

		"if( \$a == \$b ) return 0;".

		"if (\$sortorder==\"desc\")".
			"return ( \$a < \$b ) ? 1 : -1;".
		"else if (\$sortorder==\"asc\")".
			"return ( \$a > \$b ) ? 1 : -1;" );

        foreach( $jobs as $jobid => $jobattrs ) {

                        $state = $jobattrs[status];
                        $user = $jobattrs[owner];
                        $queue = $jobattrs[queue];
                        $name = $jobattrs[name];
                        $req_cpu = $jobattrs[requested_time];
                        $req_memory = $jobattrs[requested_memory];
                        $nodes = count( $jobattrs[nodes] );
                        $ppn = (int) $jobattrs[ppn] ? $jobattrs[ppn] : 1;
                        $cpus = $nodes * $ppn;
                        $start_time = (int) $jobattrs[start_timestamp];
			$runningtime = $report_time - $start_time;

			switch( $sortby ) {
				case "id":
					$sorted[$jobid] = $jobid;
					break;

				case "state":
					$sorted[$jobid] = $state;
					break;

				case "user":
					$sorted[$jobid] = $user;
					break;

				case "queue":
					$sorted[$jobid] = $queue;
					break;

				case "name":
					$sorted[$jobid] = $name;
					break;

				case "req_cpu":
					$sorted[$jobid] = $req_cpu;
					break;

				case "req_mem":
					$sorted[$jobid] = $req_memory;
					break;

				case "nodes":
					$sorted[$jobid] = $nodes;
					break;

				case "cpus":
					$sorted[$jobid] = $cpus;
					break;

				case "start":
					$sorted[$jobid] = $start_time;
					break;

				case "runningtime":
					$sorted[$jobid] = $runningtime;
					break;

				default:
					break;

			}
        }

	uasort( $sorted, $cmp );

	return $sorted;
}

function makeOverview() {

	global $jobs, $nodes, $heartbeat, $clustername, $tpl;
	global $sortorder, $sortby, $filter, $sh, $hc, $m;
	global $cluster_url, $get_metric_string, $host_url, $metrics;
	global $start, $end, $reports;

	$metricname = $m;

	$tpl->assign("sortorder", $sortorder );
	$tpl->assign("sortby", $sortby );

	$sorted_jobs = sortJobs( $jobs, $sortby, $sortorder );

	$even = 1;

	$overview_jobs = count( $sorted_jobs );
	$overview_nodes = count( $gnodes );
	$overview_cpus = 0;

	$f_cpus = 0;
	$f_jobs = 0;

	foreach( $sorted_jobs as $jobid => $sortdec ) {

		$report_time = $jobs[$jobid][reported];

		$nodes = count( $jobs[$jobid][nodes] );
		$ppn = (int) $jobs[$jobid][ppn] ? $jobs[$jobid][ppn] : 1;
		$cpus = $nodes * $ppn;

		$overview_cpus = $overview_cpus + $cpus;

		if( $report_time == $heartbeat ) {

			$display_job = 1;

			foreach( $filter as $filtername=>$filtervalue ) {

				if( $filtername == 'id' && $jobid != $filtervalue )
					$display_job = 0;
				else if( $filtername == 'state' && $jobs[$jobid][status] != $filtervalue )
					$display_job = 0;
				else if( $filtername == 'queue' && $jobs[$jobid][queue] != $filtervalue )
					$display_job = 0;
				else if( $filtername == 'user' && $jobs[$jobid][owner] != $filtervalue )
					$display_job = 0;
			}

			if( $display_job ) {


				$tpl->newBlock("node");
				$tpl->assign( "clustername", $clustername );
				$tpl->assign("id", $jobid );
				$tpl->assign("state", $jobs[$jobid][status] );
				$tpl->assign("user", $jobs[$jobid][owner] );
				$tpl->assign("queue", $jobs[$jobid][queue] );
				$tpl->assign("name", $jobs[$jobid][name] );
				$domain = $jobs[$jobid][domain];
				$tpl->assign("req_cpu", makeTime( timeToEpoch( $jobs[$jobid][requested_time] ) ) );
				$tpl->assign("req_memory", $jobs[$jobid][requested_memory] );
				$nodes = count( $jobs[$jobid][nodes] );
				$ppn = (int) $jobs[$jobid][ppn] ? $jobs[$jobid][ppn] : 1;
				$cpus = $nodes * $ppn;
				$tpl->assign("nodes", $nodes );
				$tpl->assign("cpus", $cpus );
				$start_time = (int) $jobs[$jobid][start_timestamp];
				$job_start = $start_time;

				$f_cpus = $f_cpus + $cpus;
				$f_jobs++;

				if( $even ) {

					$tpl->assign("nodeclass", "even");
					$even = 0;
				} else {

					$tpl->assign("nodeclass", "odd");
					$even = 1;
				}

				if( $start_time ) {

					$runningtime = makeTime( $report_time - $start_time );
					$job_runningtime = $report_time - $start_time;
					$tpl->assign("started", makeDate( $start_time ) );
					$tpl->assign("runningtime", $runningtime );
				}
			}
		}
	}

	$tpl->assignGlobal("cpus_nr", $overview_cpus );
	$tpl->assignGlobal("jobs_nr", $overview_jobs );
	$tpl->assignGlobal("nodes_nr", $overview_nodes );
	$tpl->assignGlobal("report_time", makeDate( $heartbeat));
	
	$tpl->assignGlobal("f_cpus_nr", $f_cpus );
	$tpl->assignGlobal("f_jobs_nr", $f_jobs );

	if( array_key_exists( "id", $filter ) ) {
		$tpl->newBlock( "showhosts" );

		# Present a width list
		$cols_menu = "<SELECT NAME=\"hc\" OnChange=\"toga_form.submit();\">\n";

		$hostcols = ($hc) ? $hc : 4;

		foreach(range(1,25) as $cols) {
			$cols_menu .= "<OPTION VALUE=$cols ";
			if ($cols == $hostcols)
				$cols_menu .= "SELECTED";
			$cols_menu .= ">$cols\n";
		}
		$cols_menu .= "</SELECT>\n";

		//$tpl->assign("cluster", $clustername);
		$tpl->assign("metric","$metricname $units");
		$tpl->assign("id", $id);
		# Host columns menu defined in header.php
		$tpl->assign("cols_menu", $cols_menu);

		if( $sh) $showhosts = $sh;
		if( !$showhosts) $showhosts = 0;
		$tpl->assign("checked$showhosts", "checked");

		if( $showhosts ) {
			//-----

			if( !isset($start) ) $start="jobstart";
			if( !isset($stop) ) $stop="now";
			//$tpl->assign("start", $start);
			//$tpl->assign("stop", $stop);

			$sorted_hosts = array();
			$hosts_up = $jobs[$filter[id]][nodes];

			$r = intval($job_runningtime * 1.25);

			$jobrange = ($job_runningtime < 3600) ? -3600 : -$r ;
			$jobstart = $report_time - $job_runningtime;

			if ($reports[$metricname])
				$metricval = "g";
			else
				$metricval = "m";
						
			foreach ($hosts_up as $host ) {
				$host = $host. '.'.$domain;
				$cpus = $metrics[$host]["cpu_num"][VAL];
				if (!$cpus) $cpus=1;
				$load_one  = $metrics[$host]["load_one"][VAL];
				$load = ((float) $load_one)/$cpus;
				$host_load[$host] = $load;
				$percent_hosts[load_color($load)] += 1;
				if ($metricname=="load_one")
					$sorted_hosts[$host] = $load;
				else
					$sorted_hosts[$host] = $metrics[$host][$metricname][VAL];
			}
			switch ($sort) {
				case "descending":
					arsort($sorted_hosts);
					break;
				case "by hostname":
					ksort($sorted_hosts);
					break;
				default:
				case "ascending":
					asort($sorted_hosts);
					break;
			}

			//$sorted_hosts = array_merge($down_hosts, $sorted_hosts);

			# First pass to find the max value in all graphs for this
			# metric. The $start,$end variables comes from get_context.php,
			# included in index.php.
			list($min, $max) = find_limits($sorted_hosts, $metricname);

			# Second pass to output the graphs or metrics.
			$i = 1;
			foreach ( $sorted_hosts as $host=>$value  ) {
				$tpl->newBlock ("sorted_list");
				//$host = $host. '.'.$domain;
				$host_url = rawurlencode($host);
				$cluster_url = rawurlencode($clustername);

				$textval = "";
				//printf("host = %s, value = %s", $host, $value);
				//echo "$host: $value, ";
				$val = $metrics[$host][$metricname];
				$class = "metric";
				$host_link="\"?c=$cluster_url&h=$host_url&r=job&jr=$jobrange&js=$jobstart\"";

				if ($val[TYPE]=="timestamp" or $always_timestamp[$metricname]) {
					$textval = date("r", $val[VAL]);
				} elseif ($val[TYPE]=="string" or $val[SLOPE]=="zero" or $always_constant[$metricname] or ($max_graphs > 0 and $i > $max_graphs )) {
					$textval = "$val[VAL] $val[UNITS]";
				} else {
					$load_color = load_color($host_load[$host]);
					$graphargs = ($reports[$metricname]) ? "g=$metricname&" : "m=$metricname&";
					$graphargs .= "z=small&c=$cluster_url&h=$host_url&l=$load_color" ."&v=$val[VAL]&x=$max&n=$min&r=job&jr=$jobrange&js=$jobstart";
				}
				if ($textval) {
					$cell="<td class=$class>".  "<b><a href=$host_link>$host</a></b><br>".  "<i>$metricname:</i> <b>$textval</b></td>";
				} else {
					$cell="<td><a href=$host_link>".  "<img src=\"../../graph.php?$graphargs\" ".  "alt=\"$host\" height=112 width=225 border=0></a></td>";
				}

				$tpl->assign("metric_image", $cell);
				if (! ($i++ % $hostcols) )
					 $tpl->assign ("br", "</tr><tr>");
			}
		}
//---
	}
}
?>