package Munin::Master::HTMLConfig;

use warnings;
use strict;

use Exporter;
our (@ISA, @EXPORT);
@ISA = qw(Exporter);
@EXPORT = qw(generate_config get_peer_nodes);

use POSIX qw(strftime);
use Getopt::Long;
use Time::HiRes;
use Scalar::Util qw( weaken );

use Munin::Master::Logger;
use Munin::Master::Utils;
use Data::Dumper;

use Log::Log4perl qw( :easy );

my @times = ("day", "week", "month", "year");

my $DEBUG = 0;
my $INDEX_FILENAME = "index.html";

my $config;
my $limits;
my $cache;

my $categories;
my $problems;

sub generate_config {
    my $use_cache = shift;
    if ($use_cache) {
	$cache = undef; # undef, for RAM usage
	# if there is some cache, use it (for cgi)
    	my $newcache = munin_readconfig_part('htmlconf', 1);
	if (defined $newcache) {
		$cache = $newcache;
		return $cache;
	}
    }
    $categories = {};
    $problems = {"criticals" => [], "warnings" => [], "unknowns" => []};
    my $rev = munin_configpart_revision();

    $config = munin_readconfig_part('datafile', 0);
    initiate_cgiurl_graph(); # we don't set a default like for others
    if ($rev != munin_configpart_revision()) {
	# convert config for html generation: reorder nodes to their rightful group
	node_reorder($config);
    }

    $limits = munin_readconfig_part("limits");
    # if only limits changed, still update our cache
    if ($rev != munin_configpart_revision()) {
	$cache = undef; # undef, for RAM usage
	$cache = get_group_tree($config);
    }

    return $cache;
}

sub node_reorder {
	my $totalconfig = shift;
	my $group = shift || $config;
	my $children = munin_get_sorted_children($group);
	# traverse group
	foreach my $child (@$children) {
		# if this is a node
		if(defined $child->{'address'}){
			# if renaming is active
			if(defined $child->{"html_rename"}){
				(my $groups, my $name) = munin_get_host_path_from_string($child->{"html_rename"});
				
				# add the node at its new place
				my $currentgroup = $totalconfig;
				foreach my $local_group (@$groups){
					if(!defined $currentgroup->{$local_group}){
						$currentgroup->{$local_group} = {'#%#name' => $local_group, '#%#parent' => $currentgroup};
						weaken($currentgroup->{$local_group}{'#%#parent'});
					}
					$currentgroup = $currentgroup->{$local_group};
				}

				if(defined $currentgroup->{$name}){
					ERROR $child->{"html_rename"} . " already exists. Renaming not possible.";
				} else {
					# remove node from structure
					undef $group->{$child->{"#%#name"}};
					
					# change name into new name
					$child->{"#%#origname"} = $child->{"#%#name"};
					$child->{"#%#name"} = $name;
					
					# add to new group
					$child->{"#%#origparent"} = $group;
					$currentgroup->{$name} = $child;
					$child->{"#%#parent"} = $currentgroup;
					weaken($child->{"#%#parent"});
				}
			}
		} else {
			# reorder group
			node_reorder($totalconfig, $child);
		}
	}
}

sub initiate_cgiurl_graph {
    if (!defined $config->{'cgiurl_graph'}) {
        if (defined $config->{'cgiurl'}) {
            $config->{'cgiurl_graph'} = $config->{'cgiurl'} . "/munin-cgi-graph";
        }
        else {
            $config->{'cgiurl_graph'} = "/munin-cgi/munin-cgi-graph";
        }
		DEBUG "[DEBUG] Determined that cgiurl_graph is ".$config->{'cgiurl_graph'};
    }
}

sub add_graph_to_categories {
	my $srv = shift;
	my $category = $srv->{"category"};
	my $srvname = $srv->{"label"};
	if(!defined ($categories->{$category})){
		$categories->{$category} = {};
	}
	if(!defined ($categories->{$category}->{$srvname})){
		$categories->{$category}->{$srvname} = [];
	}
	push @{$categories->{$category}->{$srvname}}, $srv;
}

sub get_group_tree {
    my $hash    = shift;
    my $base    = shift || "";

    my $graphs  = [];     # Pushy array of graphs, [ { name => 'cpu'}, ...]
    my $groups  = [];     # Slices of the $config hash
	my $cattrav = {};     # Categories, array of strings
    my $cats    = [];     # Array of graph information ('categories')
    my $path    = [];     # (temporary) array of paths relevant to . (here)
    my $rpath   = undef;
    my $visible = 0;
    my $css_name;

    my $children = munin_get_sorted_children($hash);

    foreach my $child (@$children) {
        next unless defined $child and ref($child) eq "HASH" and keys %$child;

		$child->{"#%#ParentsNameAsString"} = munin_get_node_name($hash); # TODO: is this value used anywhere?

        if (defined $child->{"graph_title"} and munin_get_bool($child, "graph", 1)) { #graph
		    $child->{'#%#is_service'} = 1; # TODO: is this value used anywhere?
			my $childname = munin_get_node_name($child);
			my $childnode = generate_service_templates($child);
			push @$graphs, {"name" => $childname};
			$childnode->{'name'} = $child->{"graph_title"};
			add_graph_to_categories($childnode);

		    # Make sure the link gets right even if the service has subservices
	    	if (munin_has_subservices ($child)) {
				$childnode->{'url'}  = $base . $childname . "/$INDEX_FILENAME"; #TODO: html generation should generate urls
		    } else {
				$childnode->{'url'}  = $base . $childname . ".html"; #TODO: html generation should generate urls
	    	}

            $childnode->{'host_url'}  = $base . $INDEX_FILENAME;

            #TODO: Think of a nicer way to generate relative urls (reference #1)
			for (my $shrinkpath = $childnode->{'url'}, my $counter = 0;
			 $shrinkpath;
			 $shrinkpath =~ s/^[^\/]+\/?//, $counter++)
	    	{
                die ("Munin::Master::HTMLConfig ran into an endless loop") if ($counter >= 100);
                $childnode->{'url' . $counter} = $shrinkpath;
            }

            push @{$cattrav->{lc munin_get($child, "graph_category", "other")}}, $childnode;

		    # If this is a multigraph plugin there may be sub-graphs.
		    push( @$groups, grep {defined $_} get_group_tree($child, $base.munin_get_node_name($child)."/"));

            $visible = 1;
		}
        elsif (ref($child) eq "HASH" and !defined $child->{"graph_title"}) { #group
			push( @$groups, grep {defined $_} get_group_tree($child, $base.munin_get_node_name($child) . "/"));

			if (scalar @$groups) {
				$visible = 1;
		    }
		}
    }

	foreach my $group (@$groups) {
		$group->{'peers'} = get_peer_nodes($group->{"#%#hash"}, lc munin_get($group->{"#%#hash"}, "graph_category", "other"));
	}

    return unless $visible;

    $hash->{'#%#visible'} = 1; # TODO: is this value used anywhere?

    # We need the categories in another format.
    foreach my $cat (sort keys %$cattrav) {
        my $obj = {};
        $obj->{'name'}     = $cat;
        $obj->{'url'}      = $base . "${INDEX_FILENAME}#" . $cat;
        $obj->{'services'} = [sort {lc($a->{'name'}) cmp lc($b->{'name'})}
                @{$cattrav->{$cat}}];
        $obj->{'state_' . lc munin_category_status($hash, $limits, $cat, 1)}
            = 1;
		#TODO: shrinkpath reference #2
        for (
            my $shrinkpath = $obj->{'url'}, my $counter = 0;
            $shrinkpath =~ /\//;
            $shrinkpath =~ s/^[^\/]+\/*//, $counter++
            ) {
            die ("Munin::Master::HTMLConfig ran into an endless loop") if ($counter >= 100);
            $obj->{'url' . $counter} = $shrinkpath;
        }
        push @$cats, $obj;
    }

    # ...and we need a couple of paths available.
	# TODO: think of a nicer way to generate urls
    @$path = reverse map {
        {
            "pathname" => $_,
            "path" => (
                defined $rpath
                ? ($rpath .= "../") . $INDEX_FILENAME
                : ($rpath = ""))}
    } reverse(undef, split('\/', $base));
	
	# TODO: think of a nicer way to generate urls
    my $root_path = get_root_path($path);

    # We need a bit more info for the comparison templates
    my $compare         = munin_get_bool($hash, "compare", 1);
    my $comparecats = [];
    my $comparegroups = [];
	if($compare){
      ($compare, $comparecats, $comparegroups) = generate_compare_groups($groups);
    }
	my %group_hash = (map {$_->{'name'} => $_} @{$groups});   
 
	my $ret = {
        "name"     => munin_get_node_name($hash),
        "url"      => $base . $INDEX_FILENAME,
        "path"     => $path,
		"#%#hash"     => $hash,
        "depth" => scalar(my @splitted_base = split("/", $base . $INDEX_FILENAME))
            - 1,
        "filename"           => munin_get_html_filename($hash),
        "css_name"           => $css_name,
        "root_path"          => $root_path,
        "groups"             => $groups,
		"groups_hash"		 => \%group_hash,
        "graphs"             => $graphs,
        "multigraph"         => munin_has_subservices ($hash),
        "categories"         => $cats,
        "ngroups"            => scalar(@$groups),
        "ngraphs"            => scalar(@$graphs),
        "ncategories"        => scalar(@$cats),
        "compare"            => $compare,
        "comparegroups"      => $comparegroups,
        "ncomparegroups"     => scalar(@$comparegroups),
        "comparecategories"  => $comparecats,
        "ncomparecategories" => scalar(@$comparecats),
    };


	if($ret->{'depth'} == 0){ #root node does not have peer nodes
		# add categories
		my $catarray = [];
		foreach (sort keys %{$categories}) {
			my $currentcat = $categories->{$_};
			my $srvarray = [];
			foreach (sort keys %{$currentcat}) {
				my $srv_nodename = $_;
				$srv_nodename =~ s/ /_/g;
				my $srv = {
					"graphs" => $currentcat->{$_},
					"name" => $_,
					"service" => $srv_nodename,
				};
				push @$srvarray, $srv
			}
			my $filename = munin_get_html_filename($hash);
			$filename =~ s/index.html$/$_/;
			my $cat = {
				"name" => $_,
				"urlday" => "$_-day.html",
				"urlweek" => "$_-week.html",
				"urlmonth" => "$_-month.html",
				"urlyear" => "$_-year.html",
				"path" => $path,
				"graphs" => $srvarray,
				"filename-day" => $filename . "-day.html",
				"filename-week" => $filename . "-week.html",
				"filename-month" => $filename . "-month.html",
				"filename-year" => $filename . "-year.html",
			};
			push @$catarray, $cat;
		}
		$ret->{"problems"} = $problems;
		$ret->{"globalcats"} = $catarray;
		$ret->{"nglobalcats"} = scalar(@$catarray);
	}

    #TODO: shrinkpath reference #3
	if ($ret->{'url'} ne "/index.html") {
        for (
            my $shrinkpath = $ret->{'url'}, my $counter = 0;
            $shrinkpath =~ /\//;
            $shrinkpath =~ s/^[^\/]+\/*//, $counter++
            ) {
            die ("Munin::Master::HTMLConfig ran into an endless loop") if ($counter >= 100);
            $ret->{'url' . $counter} = $shrinkpath;
        }
    }

    return $ret;
}

sub generate_compare_groups {
  my $groups = shift;
  my $comparecats     = [];
  my $comparecatshash = {};
  my $comparegroups   = [];

  foreach my $tmpgroup (@$groups) {

    # First we gather a bit of data into comparecatshash...
    if ($tmpgroup->{'ngraphs'} > 0 && !$tmpgroup->{"multigraph"}) { # no compare links for multigraphs
      push @$comparegroups, $tmpgroup;
      foreach my $tmpcat (@{$tmpgroup->{'categories'}}) {
        $comparecatshash->{$tmpcat->{'name'}}->{'groupname'} = $tmpcat->{'name'};
        foreach my $tmpserv (@{$tmpcat->{'services'}}) {
          $comparecatshash->{$tmpcat->{'name'}}->{'services'}->{$tmpserv->{'name'}}->{'nodes'}->{$tmpgroup->{'name'}} = $tmpserv;
          $comparecatshash->{$tmpcat->{'name'}}->{'services'}->{$tmpserv->{'name'}}->{'nodes'}->{$tmpgroup->{'name'}}->{'nodename'} = $tmpgroup->{'name'};
          $comparecatshash->{$tmpcat->{'name'}}->{'services'}->{$tmpserv->{'name'}}->{'nodes'}->{$tmpgroup->{'name'}}->{'nodeurl'} = $tmpgroup->{'url'};
        }
      }
    }
  }
  if (scalar @$comparegroups <= 1) {
    return (0, [], []); # ($compare, $comparecats, $comparegroups)
  }

  # restructure it, comparecats need to end up looking like: ->[i]->{'services'}->[i]->{'nodes'}->[i]->{*}
  # not really restructuring; this just sorts all arrays, but doesn't take the node order into account.
  my $empty_node = {

  };

  foreach my $tmpcat (sort keys %$comparecatshash) {
    foreach my $tmpserv (sort keys %{$comparecatshash->{$tmpcat}->{'services'}}) {
      my @nodelist = map {defined $comparecatshash->{$tmpcat}->{'services'}->{$tmpserv}->{'nodes'}->{$_->{'name'}} ?
                        $comparecatshash->{$tmpcat}->{'services'}->{$tmpserv}->{'nodes'}->{$_->{'name'}} :
                        {
                          nodename => $_->{'name'},
                        }
                      } (@$groups);
      delete $comparecatshash->{$tmpcat}->{'services'}->{$tmpserv}->{'nodes'};
      $comparecatshash->{$tmpcat}->{'services'}->{$tmpserv}->{'nodes'} = \@nodelist;
    }
    my @servlist = map {$comparecatshash->{$tmpcat}->{'services'}->{$_}} sort keys %{$comparecatshash->{$tmpcat}->{'services'}};
    delete $comparecatshash->{$tmpcat}->{'services'};
    $comparecatshash->{$tmpcat}->{'services'} = \@servlist;
  }
  @$comparecats = map {$comparecatshash->{$_}} sort keys %$comparecatshash;
  return (1, $comparecats, $comparegroups);
}

# This is called both at group level, service level, and subservice level
sub munin_get_sorted_children {
    my $hash        = shift || return;

    my $children    = munin_get_children($hash);
    my $group_order;
    my $ret         = [];

    if (defined $hash->{'group_order'}) {
	$group_order = $hash->{'group_order'};
    } elsif (defined $hash->{'domain_order'}) {
	$group_order = $hash->{'domain_order'};
    } elsif (defined $hash->{'node_order'}) {
	$group_order = $hash->{'node_order'};
    } else {
    	$group_order = "";
    } 

    my %children = map {munin_get_node_name($_) => $_} @$children;

    foreach my $group (split /\s+/, $group_order) {
        if (defined $children{$group}) {
            push @$ret, $children{$group};
            delete $children{$group};
        }
        elsif ($group =~ /^(.+)=([^=]+)$/) {

            # "Borrow" the graph from another group
            my $groupname = $1;
            my $path      = $2;
            my $borrowed  = munin_get_node_partialpath($hash, $path);
            if (defined $borrowed) {
                munin_copy_node_toloc($borrowed, $hash, [$groupname]);
                $hash->{$groupname}->{'#%#origin'} = $borrowed;
            }
            push @$ret, $hash->{$groupname};
        }
    }

    foreach my $group (sort {$a cmp $b} keys %children) {
        push @$ret, $children{$group};
    }

    return $ret;
}

sub generate_service_templates {

    my $service = shift || return;

    return unless munin_get_bool($service, "graph", 1);

    my %srv;
    my $fieldnum = 0;
    my @graph_info;
    my @field_info;
    my @loc       = @{munin_get_picture_loc($service)};
    my $pathnodes = get_path_nodes($service);
    my $peers     = get_peer_nodes($service,
    lc munin_get($service, "graph_category", "other"));
    my $parent = munin_get_parent_name($service);
    my $filename = munin_get_html_filename($service);

    my $root_path = get_root_path($pathnodes);
    my $bp = borrowed_path($service) || ".";

    $srv{'node'} = munin_get_node_name($service);
    DEBUG "[DEBUG] processing service: $srv{node}";
    $srv{'service'}   = $service;
    $srv{"multigraph"}= munin_has_subservices($service);
    $srv{'label'}     = munin_get($service, "graph_title");
    $srv{'category'}  = lc(munin_get($service, "graph_category", "other"));
	$srv{'path'}      = $pathnodes;
	$srv{'peers'}     = $peers;
    $srv{'root_path'} = $root_path;
	$srv{'filename'}  = $filename;

    $srv{'url'} = "$srv{node}.html";

    my $path = join('/', @loc);

    my %imgs;
    $imgs{'imgday'}   = "$path-day.png";
    $imgs{'imgweek'}  = "$path-week.png";
    $imgs{'imgmonth'} = "$path-month.png";
    $imgs{'imgyear'}  = "$path-year.png";
    
    $imgs{'cimgday'}   = "$path-day.png";
    $imgs{'cimgweek'}  = "$path-week.png";
    $imgs{'cimgmonth'} = "$path-month.png";
    $imgs{'cimgyear'}  = "$path-year.png";
    
    if (munin_get_bool($service, "graph_sums", 0)) {
        $imgs{'imgweeksum'} = "$path-week-sum.png";
        $imgs{'imgyearsum'} = "$path-year-sum.png";
    }

    # dump all the png filename to a file
    my $fh = $config->{"#%#graphs_fh"};
    if ($fh) {
	    # values %imgs = the image file
	    # get them uniq, so we don't write them twice
	    my %paths = map { $_, 1 } (values %imgs);
	    foreach my $img (keys %paths) {
		print $fh "/" . $img . "\n";
	    }
    }

    my $imgpath = $root_path;
    if ( munin_get($config, "graph_strategy", "cron") eq "cgi" ) {
	$imgpath = $config->{'cgiurl_graph'};
    }

    map { $srv{$_} = $imgpath . "/" . $imgs{$_} } keys %imgs;

    # Compute the ZOOM urls
    {
        my $epoch_now = time;
	# The intervals are a bit larger, just like the munin-graph
	my $start_day = $epoch_now - (3600 * 30);
	my $start_week = $epoch_now - (3600 * 24 * 8);
	my $start_month = $epoch_now - (3600 * 24 * 33);
	my $start_year = $epoch_now - (3600 * 24 * 400);
	my $size_x = 800;
	my $size_y = 400;
	my $common_url = "$root_path/static/dynazoom.html?cgiurl_graph=$config->{'cgiurl_graph'}&plugin_name=$path&size_x=$size_x&size_y=$size_y";
	$srv{zoomday} = "$common_url&start_epoch=$start_day&stop_epoch=$epoch_now";
	$srv{zoomweek} = "$common_url&start_epoch=$start_week&stop_epoch=$epoch_now";
	$srv{zoommonth} = "$common_url&start_epoch=$start_month&stop_epoch=$epoch_now";
	$srv{zoomyear} = "$common_url&start_epoch=$start_year&stop_epoch=$epoch_now";
    }

	for my $scale (@times) {
		my ($w, $h) = get_png_size(munin_get_picture_filename($service, $scale));
		if ($w && $h) {
			$srv{"img" . $scale . "width"}  = $w;
			$srv{"img" . $scale . "height"} = $h;
		}
	}

    if (munin_get_bool($service, "graph_sums", 0)) {
        $srv{imgweeksum} = "$srv{node}-week-sum.png";
        $srv{imgyearsum} = "$srv{node}-year-sum.png";

        for my $scale (["week", "year"]) {
		my ($w, $h) = get_png_size(munin_get_picture_filename($service, $scale, 1));
		if ($w && $h) {
			$srv{"img" . $scale . "sumwidth"}  = $w;
			$srv{"img" . $scale . "sumheight"} = $h;
		}
        }
    }

    # Do "help" section
    if (my $info = munin_get($service, "graph_info")) {
        my %graph_info;
        $graph_info{info} = $info;
        push @{$srv{graphinfo}}, \%graph_info;
    }

    #TODO move this ugly code to the templates
	$srv{fieldlist}
        .= "<tr><th align='left' valign='top'>Field</th><th align='left' valign='top'>Type</th><th align='left' valign='top'>Warn</th><th align='left' valign='top'>Crit</th><th></tr>";
    foreach my $f (@{munin_get_field_order($service)}) {
        $f =~ s/=(.*)$//;
        my $path = $1;
        next if (!defined $service->{$f});
        my $fieldobj = $service->{$f};
        next if (ref($fieldobj) ne "HASH" or !defined $fieldobj->{'label'});
        next if (!munin_draw_field($fieldobj));

        #DEBUG "DEBUG: single_value: Checking field \"$f\" ($path).";

        if (defined $path) {

            # This call is to make sure field settings are copied
            # for aliases, .stack, et al. Todo: put that part of
            # munin_get_rrd_filename into its own functino.
            munin_get_rrd_filename($f, $path);
        }

        my %field_info;
        $fieldnum++;

        $field_info{'hr'}    = 1 unless ($fieldnum % 3);
        $field_info{'field'} = $f;
        $field_info{'label'} = munin_get($fieldobj, "label", $f);
        $field_info{'type'}  = lc(munin_get($fieldobj, "type", "GAUGE"));
        $field_info{'warn'}  = munin_get($fieldobj, "warning");
        $field_info{'crit'}  = munin_get($fieldobj, "critical");
        $field_info{'info'}  = munin_get($fieldobj, "info");
        $field_info{'extinfo'} = munin_get($fieldobj, "extinfo");

        my $state = munin_field_status($fieldobj, $limits, 1);

        if (defined $state) {
            $field_info{'state_warning'}  = $state eq "warning" ? 1 : 0;
            $field_info{'state_critical'} = $state eq "critical" ? 1 : 0;
            $field_info{'state_unknown'}  = $state eq "unknown" ? 1 : 0;
        }
        push @{$srv{'fieldinfo'}}, \%field_info;
    }

    my $state = munin_service_status($service, $limits, 1);

    if (defined $state) {
        $srv{'state_warning'}  = $state eq "warning" ? 1 : 0;
        $srv{'state_critical'} = $state eq "critical" ? 1 : 0;
        $srv{'state_unknown'}  = $state eq "unknown" ? 1 : 0;
		push @{$problems->{"warnings"}}, \%srv if $state eq "warning";
		push @{$problems->{"criticals"}}, \%srv if $state eq "critical";
		push @{$problems->{"unknowns"}}, \%srv if $state eq "unknown";
    }

    return \%srv;
}

#TODO: move path specific information to html generation
sub get_path_nodes {
    my $hash = shift || return;
    my $ret  = [];
    my $link = $INDEX_FILENAME;

    unshift @$ret, {"pathname" => munin_get_node_name($hash), "path" => ""};
    while ($hash = munin_get_parent($hash)) {
        unshift @$ret, {"pathname" => munin_get_node_name($hash), "path" => $link};
        $link = "../" . $link;
    }

    $ret->[0]->{'pathname'} = undef;
    return $ret;
}

#TODO: This really needs some refactoring
sub get_peer_nodes {
    my $hash      = shift || return;
    my $category  = shift;
    my $ret       = [];
    my $parent    = munin_get_parent($hash) || return;
    my $me        = munin_get_node_name($hash);
    my $pchildren = munin_get_children($parent);

    my @peers = map { $_->[0] }
        sort { $a->[1] cmp $b->[1] }
        map { [ $_, munin_get_node_name($_) ] } @$pchildren;

    foreach my $peer (@peers) {
        next unless defined $peer and ref($peer) eq "HASH";
        next
          if defined $category
                and lc(munin_get($peer, "graph_category", "other")) ne
                  $category;
        next
          if (!defined $peer->{'graph_title'}
              and (!defined $peer->{'#%#visible'} or !$peer->{'#%#visible'}));
        next
          if (defined $peer->{'graph_title'}
            and !munin_get_bool($peer, "graph", 1));
        my $peername = munin_get_node_name($peer);
        next
          if $peername eq "contact"
            and munin_get_node_name($parent) eq "root";
        if ($peername eq $me) {
            unshift @$ret, {"name" => $peername, "link" => undef};
        }
        else {
            # Handle different directory levels between subgraphs and regular graphs
            if (munin_has_subservices ($hash)) {
                if (munin_has_subservices ($peer)) {
                    # I've got subgraphs, peer's got subgraphs
                    unshift @$ret,
                      {"name" => $peername, "link" => "../$peername/index.html"};
                } else { 
                    # I've got subgraphs, peer's a regular graph
                    unshift @$ret,
                      {"name" => $peername, "link" => "../$peername.html"};
                } 
            } elsif (munin_has_subservices ($peer)) {
                # I'm a regular graph, peer's got subgraphs
                unshift @$ret,
                  {"name" => $peername, "link" => "$peername/index.html"};
            } else {
                if (defined $peer->{'graph_title'}) {
                    # Both me and peer are regular graphs
                    unshift @$ret,
                      {"name" => $peername, "link" => "$peername.html"};
                }
                else {
                    # We're not on the graph level -- handle group peering
                    unshift @$ret,
                      {"name" => $peername, "link" => "../$peername/index.html"};
                }
            }
        }
    }
    return $ret;
}

#TODO: move url logic to html generation
sub get_root_path{
    my ($path) = @_;
    if ($path) {
        (my $root = $path->[0]->{'path'}) =~ s/\/index.html$//;
        return $root;
    }
    return "";
}

#TODO: move url logic to html generation
sub borrowed_path {
    # I wish I knew what this function does.  It appears to make
    # .. path elements to climb up the directory hierarchy.  To
    # "borrow" something from a different directory level.

    my $hash     = shift;
    my $prepath  = shift || "";
    my $postpath = shift || "";

    return unless defined $hash and ref($hash) eq "HASH";

    if (defined $hash->{'#%#origin'}) {
        return
	    $prepath . "../"
            . munin_get_node_name($hash->{'#%#origin'}) . "/"
            . $postpath;
    }
    else {
        if (defined $hash->{'#%#parent'}) {
            if (defined $hash->{'graph_title'}) {
                return borrowed_path($hash->{'#%#parent'}, $prepath . "../",
                    $postpath);
            }
            else {
                return borrowed_path(
                    $hash->{'#%#parent'},
                    $prepath . "../",
                    munin_get_node_name($hash) . "/" . $postpath
                );
            }
        }
        else {
            return;
        }
    }
}

#TODO: This method is obsolete when cgi-graphing is the only strategy left
sub get_png_size {
    my $filename = shift;
    my $width    = undef;
    my $height   = undef;

    return (undef, undef) if (munin_get($config, "graph_strategy", "cron") eq "cgi") ;

    if (open(my $PNG, '<', $filename)) {
        my $incoming;
        binmode($PNG);
        if (read($PNG, $incoming, 4)) {
            if ($incoming =~ /PNG$/) {
                if (read($PNG, $incoming, 12)) {
                    if (read($PNG, $incoming, 4)) {
                        $width = unpack("N", $incoming);
                        read($PNG, $incoming, 4);
                        $height = unpack("N", $incoming);
                    }
                }
            }
        }
        close($PNG);
    }

    return ($width, $height);
}



1;
