# 
# PERL mapweaver module by gary68
#
#
#
#
# Copyright(C)2011, Gerhard Schwanz
#
# This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the 
# Free Software Foundation; either version 3 of the License, or(at your option)any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with this program; if not, see <http://www.gnu.org/licenses/>
#


package mwMulti; 

use strict;
use warnings;

use mwMap;
use mwMisc;
use mwFile;
use mwLabel;
use mwConfig;
use mwRules;

use Math::Polygon;



use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);

require Exporter;

@ISA = qw(Exporter AutoLoader);

@EXPORT = qw(processMultipolygons

	);

my $newId = 0;

my %multiNodes =();
my %multiTags =();
my %multiPaths =();

my %wayUsed =();

# -------------------------------------------------------------------------

sub processMultipolygons{	my $notDrawnMP = 0;
	my $mp = 0;
	my $mpLabels = 0;
	my $mpNotDrawnLabels = 0;
	print "draw multipolygons...\n";

	preprocessMultipolygons();

	foreach my $multiId(keys %multiTags){
		my $ruleRef = getAreaRule(\@{$multiTags{$multiId}});

		if(defined $ruleRef){
			my $svgText = "";
			my $icon = "";
			if($$ruleRef{'icon'}ne "none"){				$icon = $$ruleRef{'icon'};
		}			else{				my $col = $$ruleRef{'color'};
				$svgText = "fill=\"$col\" ";
		}
			my $ref = $multiPaths{$multiId}[0]; # first, outer way
			my $size = areaSize($ref);

			if($size >= cv('minareasize')){				drawArea($svgText, $icon, $multiPaths{$multiId}, 1, "multi");
				$mp++;


				# LABELS
				my $name = ""; my $ref1;
				if(cv('ignorelabels')eq "0"){    		($name, $ref1)= createLabel($multiTags{$multiId}, $$ruleRef{'label'}, 0, 0);

	    			if(($$ruleRef{'label'}ne "none")and 
		    	(cv('nolabel')eq "1")and 
			    ($name eq ""))				   {
					    $name = "NO LABEL"; 
	    		}               }
				if($name ne ""){					if($size >= cv('minarealabelsize')){						$mpLabels++;
						if(cv('debug')eq "1"){print "MP LABEL: $name, size: $$ruleRef{'labelsize'}, color: $$ruleRef{'labelcolor'}\n";}
						my($x, $y)= areaCenter($multiPaths{$multiId}[0]);


						my $labelFont = $$ruleRef{'labelfont'};
						my $labelFontFamily = $$ruleRef{'labelfontfamily'};
						my $labelSize = $$ruleRef{'labelsize'};
						my $color = $$ruleRef{'labelcolor'};
						my $labelBold = $$ruleRef{'labelbold'};
						my $labelItalic = $$ruleRef{'labelitalic'};
						my $labelHalo = $$ruleRef{'labelhalo'};
						my $labelHaloColor = $$ruleRef{'labelhalocolor'};

						my $svgText = createTextSVG($labelFontFamily, $labelFont, $labelBold, $labelItalic, $labelSize, $color, $labelHalo, $labelHaloColor);  






						# $svgText = createTextSVG(undef, undef, $$ruleRef{'labelsize'}, $$ruleRef{'labelcolor'}, undef, undef);
						if(cv('debug')eq "1"){print "MP LABEL: svg: \"$svgText\"\n";}						placeLabelAndIcon($x, $y, 1, 0, $name, $svgText, "none", 0, 0, "arealabels");
				}# if size
					else{						$mpNotDrawnLabels++;
				}			}				else{
			}		}			else{				$notDrawnMP++;
		}
	}# if rule
}# foreach multi
	print "$mp multipolygon areas drawn, $notDrawnMP not drawn because they were too small.\n";
	print "$mpLabels multipolygon labels drawn, $mpNotDrawnLabels not drawn because belonging areas were too small.\n";
}
# ------------------------------------------------------------------------------------------

sub preprocessMultipolygons{#
# preprecess all multipolygons
#

	my($wayNodesRef, $wayTagsRef)= getWayPointers();
	my($relationMembersRef, $relationTagsRef)= getRelationPointers();

	foreach my $relId(keys %$relationMembersRef){		my $isMulti = 0;
		foreach my $tag(@{$$relationTagsRef{$relId}}){			if(($tag->[0] eq "type")and($tag->[1] eq "multipolygon")){$isMulti = 1;}	}
		if($isMulti){			if(cv('debug')eq "1"){print "\n---------------------------------------------------\n";}			if(cv('debug')eq "1"){print "\nRelation $relId is multipolygon!\n";}			
			# get inner and outer ways
			my(@innerWays)=(); my(@outerWays)=();
			foreach my $member(@{$$relationMembersRef{$relId}}){				if(($member->[0] eq "way")and($member->[2] eq "outer")and(defined @{$$wayNodesRef{$member->[1]}})){push @outerWays, $member->[1];}				if(($member->[0] eq "way")and($member->[2] eq "inner")and(defined @{$$wayNodesRef{$member->[1]}})){push @innerWays, $member->[1];}		}			if(cv('debug')eq "1"){print "OUTER WAYS: @outerWays\n";}			if(cv('debug')eq "1"){print "INNER WAYS: @innerWays\n";}
			my($ringsWaysRef, $ringsNodesRef);
			my @ringWaysInner =(); my @ringNodesInner =(); my @ringTagsInner =();
			# build rings inner
			if(scalar @innerWays > 0){		($ringsWaysRef, $ringsNodesRef)= buildRings(\@innerWays, 1);
				@ringWaysInner = @$ringsWaysRef; 
				@ringNodesInner = @$ringsNodesRef;
				for(my $ring=0; $ring<=$#ringWaysInner; $ring++){					if(cv('debug')eq "1"){print "INNER RING $ring: @{$ringWaysInner[$ring]}\n";}					my $firstWay = $ringWaysInner[$ring]->[0];
					if(scalar @{$ringWaysInner[$ring]}== 1){$wayUsed{$firstWay}= 1;}# way will be marked as used/drawn by multipolygon

					@{$ringTagsInner[$ring]}= @{$$wayTagsRef{$firstWay}}; # ring will be tagged like first contained way
					if(cv('debug')eq "1"){						print "tags from first way...\n";
						foreach my $tag(@{$$wayTagsRef{$firstWay}}){							print "  $tag->[0] - $tag->[1]\n";
					}				}					if((scalar @{$$wayTagsRef{$firstWay}})== 0){						if(cv('debug')eq "1"){print "tags set to hole in mp.\n";}						push @{$ringTagsInner[$ring]}, ["multihole", "yes"];
				}			}		}
			# build rings outer
			my @ringWaysOuter =(); my @ringNodesOuter =(); my @ringTagsOuter =();
			if(scalar @outerWays > 0){		($ringsWaysRef, $ringsNodesRef)= buildRings(\@outerWays, 1);
				@ringWaysOuter = @$ringsWaysRef; # not necessary for outer
				@ringNodesOuter = @$ringsNodesRef;
				for(my $ring=0; $ring<=$#ringWaysOuter; $ring++){					if(cv('debug')eq "1"){print "OUTER RING $ring: @{$ringWaysOuter[$ring]}\n";}					my $firstWay = $ringWaysOuter[$ring]->[0];
					if(scalar @{$ringWaysOuter[$ring]}== 1){$wayUsed{$firstWay}= 1;}					@{$ringTagsOuter[$ring]}= @{$$relationTagsRef{$relId}}; # tags from relation
					if(cv('debug')eq "1"){						print "tags from relation...\n";
						foreach my $tag(@{$$relationTagsRef{$relId}}){							print "  $tag->[0] - $tag->[1]\n";
					}				}					if(scalar @{$$relationTagsRef{$relId}}== 1){						@{$ringTagsOuter[$ring]}= @{$$wayTagsRef{$firstWay}}; # ring will be tagged like first way
 				}			}		}# outer
			
			my @ringNodesTotal =(@ringNodesInner, @ringNodesOuter);
			my @ringWaysTotal =(@ringWaysInner, @ringWaysOuter);
			my @ringTagsTotal =(@ringTagsInner, @ringTagsOuter);

			processRings(\@ringNodesTotal, \@ringWaysTotal, \@ringTagsTotal);
	}# multi

}# relIds
}
# -----------------------------------------------------------------------------------------

sub processRings{#
# process rings of multipolygons and create path data for svg
#
	my($ref1, $ref2, $ref3)= @_;
	my @ringNodes = @$ref1;
	my @ringWays = @$ref2;
	my @ringTags = @$ref3;
	my @polygon =();
	my @polygonSize =();
	my @ringIsIn =();
	my @stack =(); # all created stacks
	my %selectedStacks =(); # stacks selected for processing 
	my $actualLayer = 0; # for new tags
	# rings referenced by array index

	my($lonRef, $latRef)= getNodePointers();
	my($wayNodesRef, $wayTagsRef)= getWayPointers();

	# create polygons
	if(cv('debug')eq "1"){print "CREATING POLYGONS\n";}	for(my $ring = 0; $ring <= $#ringWays; $ring++){		my @poly =();
		foreach my $node(@{$ringNodes[$ring]}){			push @poly, [$$lonRef{$node}, $$latRef{$node}];
	}		my($p)= Math::Polygon->new(@poly);
		$polygon[$ring] = $p;
		$polygonSize[$ring] = $p->area;
		if(cv('debug')eq "1"){
			print "  POLYGON $ring - created, size = $polygonSize[$ring] \n"; 
			foreach my $tag(@{$ringTags[$ring]}){				print "    $tag->[0] - $tag->[1]\n";
		}	}}

	# create is_in list(unsorted)for each ring
	if(cv('debug')eq "1"){print "CALC isIn\n";}	for(my $ring1=0; $ring1<=$#polygon; $ring1++){		my $res = 0;
		for(my $ring2=0; $ring2<=$#polygon; $ring2++){			if($ring1 < $ring2){				$res = isIn($polygon[$ring1], $polygon[$ring2]);
				if($res == 1){
					push @{$ringIsIn[$ring1]}, $ring2; 
					if(cv('debug')eq "1"){print "  $ring1 isIn $ring2\n";}			}
				if($res == 2){
					push @{$ringIsIn[$ring2]}, $ring1; 
					if(cv('debug')eq "1"){print "  $ring2 isIn $ring1\n";}			}
		}	}}	if(cv('debug')eq "1"){		print "IS IN LIST\n";
		for(my $ring1=0; $ring1<=$#ringNodes; $ring1++){			if(defined @{$ringIsIn[$ring1]}){				print "  ring $ring1 isIn - @{$ringIsIn[$ring1]}\n";
		}	}		print "\n";
}
	# sort is_in list, biggest first
	if(cv('debug')eq "1"){print "SORTING isIn\n";}	for(my $ring=0; $ring<=$#ringIsIn; $ring++){		my @isIn =();
		foreach my $ring2(@{$ringIsIn[$ring]}){			push @isIn, [$ring2, $polygonSize[$ring2]];
	}		@isIn = sort{$a->[1] <=> $b->[1]}(@isIn); # sorted array

		my @isIn2 =(); # only ring numbers
		foreach my $temp(@isIn){			push @isIn2, $temp->[0];
	}		@{$stack[$ring]}= reverse(@isIn2); 
		push @{$stack[$ring]}, $ring; # sorted descending and ring self appended
		if(cv('debug')eq "1"){print "  stack ring $ring sorted: @{$stack[$ring]}\n";}}
	# find tops and select stacks
	if(cv('debug')eq "1"){print "SELECTING STACKS\n";}	my $actualStack = 0;
	for(my $stackNumber=0; $stackNumber<=$#stack; $stackNumber++){		# look for top element
		my $topElement = $stack[$stackNumber]->[(scalar @{$stack[$stackNumber]}- 1)];
		my $found = 0;
		for(my $stackNumber2=0; $stackNumber2<=$#stack; $stackNumber2++){			if($stackNumber != $stackNumber2){				foreach my $ring(@{$stack[$stackNumber2]}){					if($ring == $topElement){
						$found = 1;
						if(cv('debug')eq "1"){print "      element also found in stack $stackNumber2\n";}				}			}		}	}
		if($found == 0){			@{$selectedStacks{$actualStack}}= @{$stack[$stackNumber]};
			$actualStack++;
			if(cv('debug')eq "1"){print "    stack $stackNumber has been selected.\n";}	}	
}	
	# process selected stacks

	if(cv('debug')eq "1"){print "PROCESS SELECTED STACKS\n";}	# while stacks left
	while(scalar(keys %selectedStacks)> 0){		my(@k)= keys %selectedStacks;
		if(cv('debug')eq "1"){print "  stacks available: @k\n";}		my @nodes =();
		my @nodesOld;
		my @processedStacks =();

		# select one bottom element 
		my $key = $k[0]; # key of first stack
		if(cv('debug')eq "1"){print "  stack nr $key selected\n";}		my $ringToDraw = $selectedStacks{$key}[0];
		if(cv('debug')eq "1"){print "  ring to draw: $ringToDraw\n";}
		push @nodesOld, @{$ringNodes[$ringToDraw]}; # outer polygon
		push @nodes, [@{$ringNodes[$ringToDraw]}]; # outer polygon as array

		# and remove ring from stacks; store processed stacks
		foreach my $k2(keys %selectedStacks){			if($selectedStacks{$k2}[0] == $ringToDraw){
				shift(@{$selectedStacks{$k2}}); 
				push @processedStacks, $k2;
				if(scalar @{$selectedStacks{$k2}}== 0){delete $selectedStacks{$k2};}				if(cv('debug')eq "1"){print "  removed $ringToDraw from stack $k2\n";}		}
	}
		# foreach stack in processed stacks
		foreach my $k(@processedStacks){			# if now bottom of a stack is hole, then add this polygon to points
			if(defined $selectedStacks{$k}){				my $tempRing = $selectedStacks{$k}[0];
				my $temp = $ringTags[$tempRing]->[0]->[0];
				if(cv('debug')eq "1"){print "           testing for hole: stack $k, ring $tempRing, tag $temp\n";}				if($ringTags[$tempRing]->[0]->[0] eq "multihole"){					push @nodesOld, @{$ringNodes[$tempRing]};
					push @nodes, [@{$ringNodes[$tempRing]}];
					# print "      nodes so far: @nodes\n";
					# and remove this element from stack
					shift @{$selectedStacks{$k}};
					if(scalar @{$selectedStacks{$k}}== 0){delete $selectedStacks{$k};}					if(cv('debug')eq "1"){print "  ring $tempRing identified as hole\n";}			}		}	}
		# add way

		@{$multiNodes{$newId}}= @nodesOld;
		@{$multiTags{$newId}}= @{$ringTags[$ringToDraw]};
		@{$multiPaths{$newId}}= @nodes;

		push @{$$wayTagsRef{$newId}}, ["layer", $actualLayer];
		$actualLayer++;

		if(cv('debug')eq "1"){
			print "  DRAWN: $ringToDraw, wayId $newId\n"; 
			foreach my $tag(@{$ringTags[$ringToDraw]}){				print "    k/v $tag->[0] - $tag->[1]\n";
		}	}
		$newId++;

}#(while)}

1;