# 
# 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 mwRules ; 

use strict ;
use warnings ;

use mwConfig ;
use mwMap ;
use mwMisc ;

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

require Exporter ;

@ISA = qw ( Exporter AutoLoader ) ;

@EXPORT = qw ( 	readRules
			getNodeRule
			printNodeRules
			getWayRule
			printWayRules
			getAreaRule
			printAreaRules
			printValidObjectProperties
			getRouteColors
			getRouteRule
			printRouteRules
			adaptRuleSizes
			createLegend
		 ) ;

my @validNodeProperties = (	
			["keyValue","key and value like [amenity=hospital]"],
			["color","color of node i.e. [black]"],
			["size","size of node i.e. [50]"],
			["shape","shape of node [circle|disc|triangle|diamond|rectangle]"],
			["svgString","svg format of shape [valid svg string]"],
			["circle","add a circle to the node [yes|no]"],
			["circleColor","color of the circle i.e. [blue]"],
			["circleRadius","circle radius in meters i.e. [1000]"],
			["circleThickness","thickness of the circle i.e. [5]"],
			["circleSVGString","format of the circle []"],
			["disc","add a disc to the node [yes|no]"],
			["discColor","color of the disc i.e. [green]"],
			["discOpacity","opacity of the disc [0..100]"],
			["discRadius","radius of disc in meters i.e. [5000]"],
			["discSVGString","format of the disc []"],
			["label","label for the node like [name|ref]"],
			["labelColor","color for label text i.e. [white]"],
			["labelSize","size of label text i.e. [20]"],
			["labelFont","font for label"],
			["labelFontFamily","font family for label"],
			["labelOffset","distance of label to node i.e. [10]"],
			["labelBold","bold font for label"],
			["labelItalic","italic font for label"],
			["labelHalo","halo for label, width in pixels"],
			["labelHaloColor","color for halo"],
			["labelTransform","perl code for label name transformation"],
			["legend","is this object to be listed in map legend? [yes|no]"],
			["legendLabel","label text of object in legend i.e. [city]"],
			["icon","icon to use for node, overrides shape i.e. [icondir/icon.svg]"],
			["iconSize","size of the icon i.e. [40]"],
			["shieldName","NOT YET IMPLEMENTED"],
			["shieldSize","NOT YET IMPLEMENTED"],
			["shieldLabel","NOT YET IMPLEMENTED"],
			["fromScale","rule will only applied if scale is bigger than fromScale i.e. [5000]"],
			["toScale","rule will only applied if scale is lower than fromScale i.e. [25000]"],
			["direxclude","should these objects be excluded from directory? [yes|no]"]
					) ;

my @validWayProperties =  (	
			["keyValue","key and value like [highway=residential]"],
			["color","color for the way i.e. [gray]"],
			["size","size of the way i.e. [15]"],
			["dash","svg dash array for the way i.e. [20,20]; old mapgen values are also possible"],
			["dashCap","linecap shape for dashes like [butt|round|square]"],
			["borderColor","color of the border of the way i.e. [black]"],
			["borderSize","thickness os the border i.e. [2]"],
			["label","label to be used i.e. [name|ref]"],
			["labelColor","color of label text i.e. [blue]"],
			["labelSize","size of the label i.e. [20]"],
			["labelFont","font for label"],
			["labelFontFamily","font family for label"],
			["labelOffset","distance of label to middle of way i.e. [5]"],
			["labelBold","bold font for label"],
			["labelItalic","italic font for label"],
			["labelHalo","halo for label, width in pixels"],
			["labelHaloColor","color for halo"],
			["labelTransform","perl code for label name transformation"],
			["legend","is this object to be listed in map legend? [yes|no]"],
			["legendLabel","label text of object in legend i.e. [Highway]"],

			["svgStringBottom","format of lower way part (i.e. border) []"],
			["svgStringTop","format of upper way part []"],
			["bottomBorder","NOT YET IMPLEMENTED"],
			
			["fromScale","rule will only applied if scale is bigger than fromScale i.e. [5000]"],
			["toScale","rule will only applied if scale is lower than fromScale i.e. [25000]"],

			["direxclude","should these objects be excluded from directory? [yes|no]"]
					) ;

my @validAreaProperties = (	
			["keyValue","key and value of object i.e. [amenity=parking]"],
			["color","color of area i.e. [lightgrey]"],
			["icon","icon for fill pattern to be used i.e. [icondir/parking.svg]"],
			["label", "label text to be rendered i.e. [name]"] ,
			["labelFont","font for label"],
			["labelFontFamily","font family for label"],
			["labelColor", "color of label i.e. [green]"] ,
			["labelSize", "size of label text i.e. [20]"] ,
			["labelBold","bold font for label"],
			["labelItalic","italic font for label"],
			["labelHalo","halo for label, width in pixels"],
			["labelHaloColor","color for halo"],
			["labelTransform","perl code for label name transformation"],
			["base","should this object be drawn underneath other objects? (applies for landuse residential i.e.) [yes|no]"],
			["svgString","format of area []"],
			["legend","is this object to be listed in map legend? [yes|no]"],
			["legendLabel","label text of object in legend i.e. [Parking]"],
			["fromScale","rule will only applied if scale is bigger than fromScale i.e. [5000]"],
			["toScale","rule will only applied if scale is lower than fromScale i.e. [25000]"]
					) ;


my @validRouteProperties =  (	
			["type","type of route like [bus|hiking]"],
			["color","color of route like [red]"],
			["size","size of route i.e. [10]"],
			["dash","svg dash array style like [20,20]"],
			["linecap","linecap style [butt|round|square]"],
			["opacity","opacity of the route [0..100]"],
			["label","label to be used like [ref]"],
			["labelFont","font for label"],
			["labelFontFamily","font family for label"],
			["labelSize","size of the label i.e. [15]"],
			["nodeSize","size of nodes belonging to route i.e. [20]"],
			["fromScale","rule will only applied if scale is bigger than fromScale i.e. [5000]"],
			["toScale","rule will only applied if scale is lower than fromScale i.e. [25000]"]
					) ;


my %nodeRules = () ;
my %areaRules = () ;
my %wayRules = () ;
my %routeRules = () ;
my $nodeNr = 0 ;
my $areaNr = 0 ;
my $wayNr = 0 ;
my $routeNr = 0 ;

my $line ;
my $ruleFile ;

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

sub printValidObjectProperties {

	print "\nValid Object Properties\n" ;

	print "\nNodes\n-----\n" ;
	foreach my $p (sort {$a->[0] cmp $b->[0]} @validNodeProperties) {
		printf "%-20s %s\n", $p->[0], $p->[1] ;
	}
	print "\nWays\n----\n" ;
	foreach my $p (sort {$a->[0] cmp $b->[0]} @validWayProperties) {
		printf "%-20s %s\n", $p->[0], $p->[1] ;
	}
	print "\nAreas\n-----\n" ;
	foreach my $p (sort {$a->[0] cmp $b->[0]} @validAreaProperties) {
		printf "%-20s %s\n", $p->[0], $p->[1] ;
	}
	print "\nRoutes\n-----\n" ;
	foreach my $p (sort {$a->[0] cmp $b->[0]} @validRouteProperties) {
		printf "%-20s %s\n", $p->[0], $p->[1] ;
	}
	print "\n" ;
}


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


sub readRules {

	my $fileName = cv('style') ;
	my $nrr = 0 ; my $wrr = 0 ; my $arr = 0 ; my $rrr = 0 ; my $crr = 0 ;

	print "reading rule file $fileName\n" ;

	my %vnp = () ;
	foreach my $p ( @validNodeProperties ) { $vnp{ lc ( $p->[0] ) } = 1 ; }

	my %vwp = () ;
	foreach my $p ( @validWayProperties ) { $vwp{ lc ( $p->[0] ) } = 1 ; }

	my %vap = () ;
	foreach my $p ( @validAreaProperties ) { $vap{ lc ( $p->[0] ) } = 1 ; }

	my %vrp = () ;
	foreach my $p ( @validRouteProperties ) { $vrp{ lc ( $p->[0] ) } = 1 ; }

	openRuleFile($fileName) ;
	while (defined $line) {
		if ( grep /^rule node/i, $line ) {
			$nodeNr++ ;
			$nrr++ ;
			getRuleLine() ;

			# set defaults first
			$nodeRules{ $nodeNr }{ 'size' } = cv( 'ruleDefaultNodeSize' ) ;
			$nodeRules{ $nodeNr }{ 'color' } = cv( 'ruleDefaultNodeColor' ) ;
			$nodeRules{ $nodeNr }{ 'shape' } = cv( 'ruleDefaultNodeShape' ) ;

			$nodeRules{ $nodeNr }{ 'label' } = cv( 'ruleDefaultNodeLabel' ) ;
			$nodeRules{ $nodeNr }{ 'labelfont' } = cv( 'ruleDefaultNodeLabelFont' ) ;
			$nodeRules{ $nodeNr }{ 'labelfontfamily' } = cv( 'ruleDefaultNodeLabelFontFamily' ) ;
			$nodeRules{ $nodeNr }{ 'labelsize' } = cv( 'ruleDefaultNodeLabelSize' ) ;
			$nodeRules{ $nodeNr }{ 'labelitalic' } = "no" ;
			$nodeRules{ $nodeNr }{ 'labelbold' } = "no" ;
			$nodeRules{ $nodeNr }{ 'labelhalo' } = 0 ;
			$nodeRules{ $nodeNr }{ 'labelhalocolor' } = "white" ;
			$nodeRules{ $nodeNr }{ 'labeltransform' } = "" ;
			$nodeRules{ $nodeNr }{ 'icon' } = "none" ;
			$nodeRules{ $nodeNr }{ 'iconsize' } = cv( 'ruleDefaultNodeIconSize' ) ;
			$nodeRules{ $nodeNr }{ 'legend' } = "no" ;
			$nodeRules{ $nodeNr }{ 'shieldname' } = "none" ;
			$nodeRules{ $nodeNr }{ 'svgstring' } = "" ;
			$nodeRules{ $nodeNr }{ 'legend' } = "no" ;
			$nodeRules{ $nodeNr }{ 'legendlabel' } = "" ;

			$nodeRules{ $nodeNr }{ 'circle' } = 'no' ;
			$nodeRules{ $nodeNr }{ 'circlecolor' } = 'black' ;
			$nodeRules{ $nodeNr }{ 'circleradius' } = 1000 ;
			$nodeRules{ $nodeNr }{ 'circlethickness' } = 10 ;
			$nodeRules{ $nodeNr }{ 'circlesvgstring' } = "" ;

			$nodeRules{ $nodeNr }{ 'disc' } = 'no' ;
			$nodeRules{ $nodeNr }{ 'disccolor' } = 'red' ;
			$nodeRules{ $nodeNr }{ 'discopacity' } = 50 ;
			$nodeRules{ $nodeNr }{ 'discradius' } = 1000 ;
			$nodeRules{ $nodeNr }{ 'discradius' } = 1000 ;
			$nodeRules{ $nodeNr }{ 'discsvgstring' } = '' ;

			$nodeRules{ $nodeNr }{ 'fromscale' } = cv ('ruledefaultnodefromscale') ;
			$nodeRules{ $nodeNr }{ 'toscale' } =  cv ('ruledefaultnodetoscale') ;

			$nodeRules{ $nodeNr }{ 'direxclude' } = cv('direxcludedefault') ;

			while ( ( defined $line) and ( ! grep /^rule/i, $line) ) {
				my ($k, $v) = ( $line =~ /(.+?)=(.+)/ ) ;
				if ( ( ! defined $k ) or ( ! defined $v ) ) {
					print "WARNING: could not parse rule line: $line" ;
				}
				else {
					$k = lc ( $k ) ;
					$nodeRules{ $nodeNr }{ $k } = $v ;
					if ( ! defined $vnp{$k} ) { print "WARNING: $k is not a valid node property!\n" ; }
				}
				getRuleLine() ;
			}
			if ( ! defined $nodeRules{ $nodeNr }{ 'keyvalue' } ) { die "ERROR: rule without keyValue detected!\n" ; }

		} # node

		elsif ( grep /^rule way/i, $line ) {

			$wayNr++ ;
			$wrr++ ;
			getRuleLine() ;

			# set defaults first
			$wayRules{ $wayNr }{ 'label' } = cv( 'ruleDefaultWayLabel' ) ;
			$wayRules{ $wayNr }{ 'labelfont' } = cv( 'ruleDefaultWayLabelFont' ) ;
			$wayRules{ $wayNr }{ 'labelfontfamily' } = cv( 'ruleDefaultWayLabelFontFamily' ) ;
			$wayRules{ $wayNr }{ 'labelsize' } = cv( 'ruleDefaultWayLabelSize' ) ;
			$wayRules{ $wayNr }{ 'labelcolor' } = cv( 'ruleDefaultWayLabelColor' ) ;
			$wayRules{ $wayNr }{ 'labelfont' } = cv( 'ruleDefaultWayLabelFont' ) ;
			$wayRules{ $wayNr }{ 'labeloffset' } = cv( 'ruleDefaultWayLabelOffset' ) ;
			$wayRules{ $wayNr }{ 'labelitalic' } = "no" ;
			$wayRules{ $wayNr }{ 'labelbold' } = "no" ;
			$wayRules{ $wayNr }{ 'labelhalo' } = 0 ;
			$wayRules{ $wayNr }{ 'labelhalocolor' } = "white" ;
			$wayRules{ $wayNr }{ 'labeltransform' } = "" ;
			$wayRules{ $wayNr }{ 'legend' } = "no" ;
			$wayRules{ $wayNr }{ 'legendlabel' } = "" ;
			$wayRules{ $wayNr }{ 'color' } = cv( 'ruleDefaultWayColor' ) ;
			$wayRules{ $wayNr }{ 'size' } = cv( 'ruleDefaultWaySize' ) ;
			$wayRules{ $wayNr }{ 'bordercolor' } = cv( 'ruleDefaultWayBorderColor' ) ;
			$wayRules{ $wayNr }{ 'bordersize' } = cv( 'ruleDefaultWayBorderSize' ) ;
			$wayRules{ $wayNr }{ 'dash' } = cv( 'ruleDefaultWayDash' ) ;
			$wayRules{ $wayNr }{ 'dashcap' } = cv( 'ruleDefaultWayDashCap' ) ;

			$wayRules{ $wayNr }{ 'svgstringtop' } = "" ;
			$wayRules{ $wayNr }{ 'svgstringbottom' } = "" ;

			$wayRules{ $wayNr }{ 'fromscale' } = cv ('ruledefaultwayfromscale') ;
			$wayRules{ $wayNr }{ 'toscale' } =  cv ('ruledefaultwaytoscale') ;

			$wayRules{ $wayNr }{ 'direxclude' } = cv('direxcludedefault') ;

			while ( ( defined $line) and ( ! grep /^rule/i, $line) ) {
				my ($k, $v) = ( $line =~ /(.+?)=(.+)/ ) ;
				if ( ( ! defined $k ) or ( ! defined $v ) ) {
					print "WARNING: could not parse rule line: $line" ;
				}
				else {
					$k = lc ( $k ) ;
					$wayRules{ $wayNr }{ $k } = $v ;
					if ( ! defined $vwp{$k} ) { print "WARNING: $k is not a valid way property!\n" ; }
				}
				getRuleLine() ;
			}
			if ( ! defined $wayRules{ $wayNr }{ 'keyvalue' } ) { die "ERROR: rule without keyValue detected!\n" ; }

		} # way

		elsif ( grep /^rule area/i, $line ) {
			$areaNr++ ;
			$arr++ ;
			getRuleLine() ;

			# set defaults first
			$areaRules{ $areaNr }{ 'label' } = "none" ;
			$areaRules{ $areaNr }{ 'labelfont' } = cv( 'ruleDefaultAreaLabelFont' ) ;
			$areaRules{ $areaNr }{ 'labelfontfamily' } = cv( 'ruleDefaultAreaLabelFontFamily' ) ;
			$areaRules{ $areaNr }{ 'labelcolor' } = "black" ;
			$areaRules{ $areaNr }{ 'labelsize' } = 30 ;
			$areaRules{ $areaNr }{ 'labelitalic' } = "no" ;
			$areaRules{ $areaNr }{ 'labelbold' } = "no" ;
			$areaRules{ $areaNr }{ 'labelhalo' } = 0 ;
			$areaRules{ $areaNr }{ 'labelhalocolor' } = "white" ;
			$areaRules{ $areaNr }{ 'labeltransform' } = "" ;
			$areaRules{ $areaNr }{ 'color' } = cv( 'ruleDefaultAreaColor') ;
			$areaRules{ $areaNr }{ 'icon' } = "none" ;
			$areaRules{ $areaNr }{ 'base' } = "no"  ;
			$areaRules{ $areaNr }{ 'svgstring' } = ""  ;
			$areaRules{ $areaNr }{ 'minsize' } = cv ('ruledefaultareaminsize')  ;
			$areaRules{ $areaNr }{ 'legend' } = "no" ;
			$areaRules{ $areaNr }{ 'legendlabel' } = "" ;
			$areaRules{ $areaNr }{ 'fromscale' } = cv ('ruledefaultareafromscale') ;
			$areaRules{ $areaNr }{ 'toscale' } =  cv ('ruledefaultareatoscale') ;

			while ( ( defined $line) and ( ! grep /^rule/i, $line) ) {
				my ($k, $v) = ( $line =~ /(.+?)=(.+)/ ) ;
				if ( ( ! defined $k ) or ( ! defined $v ) ) {
					print "WARNING: could not parse rule line: $line" ;
				}
				else {
					$k = lc ( $k ) ;
					$areaRules{ $areaNr }{ $k } = $v ;
					if ( ! defined $vap{$k} ) { print "WARNING: $k is not a valid area property!\n" ; }

					if ($k eq "icon") { mwMap::addAreaIcon ($v) ; }
				}
				getRuleLine() ;
			}
			if ( ! defined $areaRules{ $areaNr }{ 'keyvalue' } ) { die "ERROR: rule without keyValue detected!\n" ; }

		} # area

		elsif ( grep /^rule route/i, $line ) {
			$routeNr++ ;
			$rrr++ ;
			getRuleLine() ;

			# set defaults first
			$routeRules{ $routeNr }{ 'color' } = cv( 'ruleDefaultRouteColor' ) ;
			$routeRules{ $routeNr }{ 'size' } = cv( 'ruleDefaultRouteSize' ) ;
			$routeRules{ $routeNr }{ 'dash' } = cv( 'ruleDefaultRouteDash' ) ;
			$routeRules{ $routeNr }{ 'linecap' } = cv( 'ruleDefaultRouteLinecap' ) ;
			$routeRules{ $routeNr }{ 'opacity' } = cv( 'ruleDefaultRouteOpacity' ) ;
			$routeRules{ $routeNr }{ 'label' } = cv( 'ruleDefaultRouteLabel' ) ;
			# $routeRules{ $routeNr }{ 'labelfont' } = cv( 'ruleDefaultRouteLabelFont' ) ;
			# $routeRules{ $routeNr }{ 'labelfontfamily' } = cv( 'ruleDefaultRouteLabelFontFamily' ) ;
			# $routeRules{ $routeNr }{ 'labelsize' } = cv( 'ruleDefaultRouteLabelSize' ) ;
			$routeRules{ $routeNr }{ 'nodesize' } = cv( 'ruleDefaultRouteNodeSize' ) ;
			$routeRules{ $routeNr }{ 'fromscale' } = cv( 'ruleDefaultRouteFromScale' ) ;
			$routeRules{ $routeNr }{ 'toscale' } = cv( 'ruleDefaultRouteToScale' ) ;

			while ( ( defined $line) and ( ! grep /^rule/i, $line) ) {
				my ($k, $v) = ( $line =~ /(.+?)=(.+)/ ) ;
				if ( ( ! defined $k ) or ( ! defined $v ) ) {
					print "WARNING: could not parse rule line: $line" ;
				}
				else {
					$k = lc ( $k ) ;
					$routeRules{ $routeNr }{ $k } = $v ;
					if ( ! defined $vrp{$k} ) { print "WARNING: $k is not a valid route property!\n" ; }
				}
				getRuleLine() ;
			}
			if ( ! defined $routeRules{ $routeNr }{ 'type' } ) { die "ERROR: route rule without type detected!\n" ; }

		} # route

		elsif ( grep /^rule config/i, $line ) {
			$crr++ ;
			my ($key, $value) = ( $line =~ /^rule config\s+(.+)=(.+)/i ) ;
			if ( (defined $key) and (defined $value) ) {
				setConfigValue ($key, $value) ;
				if ( cv('debug') eq "1" ) {
					print "RULES: config changed $key=$value\n" ;
				}
			}
			getRuleLine() ;
		} # config

		else {
			getRuleLine() ;
		}

	}


	close ($ruleFile) ;

	print "rules read: $nrr nodes, $wrr ways, $arr areas, $rrr routes and $crr configs\n\n" ;

}

sub getNodeRule {

	# takes tagref and returns hashref to rule properties

	my $tagRef = shift ;

	my $scale = getScale() ;
	if ( cv('rulescaleset') != 0 ) { $scale = cv('rulescaleset') ; }
	# print "GNR: scale: $scale\n" ;

	my $ruleFound ; undef $ruleFound ;

	# print "\n" ;

	RUL2: foreach my $rule ( sort { $a <=> $b } keys %nodeRules) {
		# print "rule $rule\n" ;
		if ( ( $nodeRules{$rule}{'fromscale'} <= $scale) and ( $nodeRules{$rule}{'toscale'} >= $scale) ) {

			my @kvs = split /;/, $nodeRules{$rule}{'keyvalue'} ;
			my $allValid = 1 ;
			RUL1: foreach my $kv1 ( @kvs ) { # for each needed
				my ($k, $v) = ( $kv1 =~ /(.+)=(.+)/ ) ;
				# print "  looking for $k=$v\n" ;
				my $found = 0 ;
				RUL3: foreach my $tag ( @$tagRef) {
					# print "    actual kvs: $tag->[0]=$tag->[1]\n" ;
					if ( ( $tag->[0] eq $k) and ( ( $tag->[1] eq $v) or ( $v eq "*") ) ) {
						$found = 1 ;
						# print "    FOUND\n" ;
						last RUL3 ;
					}
				} # tags
				if ( ! $found ) { 
					$allValid = 0 ;
					last RUL1 ; 
				}
			} # kv1

			if ( $allValid ) {
				# print "ALL VALID\n" ;
				# return the first rule found
				$ruleFound = \%{ $nodeRules{ $rule } } ;
				last RUL2 ;
			}

		} # scale

	} # all rules

	return ($ruleFound) ;

}

sub printNodeRules {
	foreach my $n ( sort { $a <=> $b }  keys %nodeRules) {
		print "node rule $n\n" ;
		foreach my $v (sort keys %{$nodeRules{$n}}) {
			print "  $v=$nodeRules{$n}{$v}\n" ;
		} 
		print "\n" ;
	}
}

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



sub getWayRule {

	# takes tagref and returns hashref to rule properties

	my $tagRef = shift ;

	my $scale = getScale() ;
	if ( cv('rulescaleset') != 0 ) { $scale = cv('rulescaleset') ; }

	my $ruleFound ; undef $ruleFound ;

	RUL5: foreach my $rule ( sort { $a <=> $b } keys %wayRules) {
		# print "rule $rule\n" ;
		if ( ( $wayRules{$rule}{'fromscale'} <= $scale) and ( $wayRules{$rule}{'toscale'} >= $scale) ) {

			my @kvs = split /;/, $wayRules{$rule}{'keyvalue'} ;
			my $allValid = 1 ;
			RUL4: foreach my $kv1 ( @kvs ) { # for each needed
				my ($k, $v) = ( $kv1 =~ /(.+)=(.+)/ ) ;
				# print "  looking for $k=$v\n" ;
				my $found = 0 ;
				RUL6: foreach my $tag ( @$tagRef) {
					# print "    actual kvs: $tag->[0]=$tag->[1]\n" ;
					if ( ( $tag->[0] eq $k) and ( ( $tag->[1] eq $v) or ( $v eq "*") ) ) {
						$found = 1 ;
						# print "    FOUND\n" ;
						last RUL6 ;
					}
				} # tags
				if ( ! $found ) { 
					$allValid = 0 ;
					last RUL4 ; 
				}
			} # kv1

			if ( $allValid ) {
				# print "ALL VALID\n" ;
				# return the first rule found
				$ruleFound = \%{ $wayRules{ $rule } } ;
				last RUL5 ;
			}

		} # scale

	} # all rules

	return ($ruleFound) ;

}


sub printWayRules {
	foreach my $n ( sort { $a <=> $b }  keys %wayRules) {
		print "way rule $n\n" ;
		foreach my $v (sort keys %{$wayRules{$n}}) {
			print "  $v=$wayRules{$n}{$v}\n" ;
		} 
		print "\n" ;
	}
}


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



sub getAreaRule {

	# takes tagref and returns hashref to rule properties

	my $tagRef = shift ;

	my $scale = getScale() ;
	if ( cv('rulescaleset') != 0 ) { $scale = cv('rulescaleset') ; }

	my $ruleFound ; undef $ruleFound ;

	RUL8: foreach my $rule ( sort { $a <=> $b } keys %areaRules) {
		# print "rule $rule\n" ;
		if ( ( $areaRules{$rule}{'fromscale'} <= $scale) and ( $areaRules{$rule}{'toscale'} >= $scale) ) {

			my @kvs = split /;/, $areaRules{$rule}{'keyvalue'} ;
			my $allValid = 1 ;
			RUL7: foreach my $kv1 ( @kvs ) { # for each needed
				my ($k, $v) = ( $kv1 =~ /(.+)=(.+)/ ) ;
				# print "  looking for $k=$v\n" ;
				my $found = 0 ;
				RUL9: foreach my $tag ( @$tagRef) {
					# print "    actual kvs: $tag->[0]=$tag->[1]\n" ;
					if ( ( $tag->[0] eq $k) and ( ( $tag->[1] eq $v) or ( $v eq "*") ) ) {
						$found = 1 ;
						# print "    FOUND\n" ;
						last RUL9 ;
					}
				} # tags
				if ( ! $found ) { 
					$allValid = 0 ;
					last RUL7 ; 
				}
			} # kv1

			if ( $allValid ) {
				# print "ALL VALID\n" ;
				# return the first rule found
				$ruleFound = \%{ $areaRules{ $rule } } ;
				last RUL8 ;
			}

		} # scale

	} # all rules

	return ($ruleFound) ;

}


sub printAreaRules {
	foreach my $n ( sort { $a <=> $b }  keys %areaRules) {
		print "area rule $n\n" ;
		foreach my $v (sort keys %{$areaRules{$n}}) {
			print "  $v=$areaRules{$n}{$v}\n" ;
		} 
		print "\n" ;
	}
}

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

sub getRouteRule {
	my $tagRef = shift ;

	my $scale = getScale() ;
	if ( cv('rulescaleset') != 0 ) { $scale = cv('rulescaleset') ; }

	my $ruleFound ; undef $ruleFound ;

	my $type = getValue ("route", $tagRef) ;

	if (defined $type) {
		# print "      GRR: $type \n" ;
		RULA: foreach my $r ( sort { $a <=> $b }  keys %routeRules) {
			# print "        GRR: $routeRules{$r}{'type'}\n" ;
			if ($routeRules{$r}{'type'} eq $type) {
				if ( ( $routeRules{$r}{'fromscale'} <= $scale) and ( $routeRules{$r}{'toscale'} >= $scale) ) {
					$ruleFound = \%{ $routeRules{ $r } } ;
					last RULA ;
				}
			}
		}

	}

	return $ruleFound ;
}

sub getRouteColors {
	my %routeColors = () ;
	foreach my $n (keys %routeRules) {
		my $type = $routeRules{$n}{'type'} ;
		my $color = $routeRules{$n}{'color'} ;
		@{$routeColors{$type}} = split ( /;/, $color ) ;
	}
	return \%routeColors ;
}

sub printRouteRules {
	foreach my $n ( sort { $a <=> $b }  keys %routeRules) {
		print "route rule $n\n" ;
		foreach my $v (sort keys %{$routeRules{$n}}) {
			print "  $v=$routeRules{$n}{$v}\n" ;
		} 
		print "\n" ;
	}
}

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


sub openRuleFile {
	my $fileName = shift ;
	open ($ruleFile, "<", $fileName) or die ("ERROR: could not open rule file $fileName\n") ;
	getRuleLine() ;
}

sub getRuleLine {
	$line = <$ruleFile> ;
	if (defined $line) {	
		$line =~ s/\r//g ; # remove dos/win char at line end
	}
	while ( (defined $line) and ( (length $line < 2) or ( grep /^comment/i, $line) or ( grep /^\#/i, $line) ) ) {
		$line = <$ruleFile> ;
	}
	return $line ;
}

sub adaptRuleSizes {
	foreach my $r ( keys %nodeRules ) {
		foreach my $p ( qw (iconSize labelOffset labelSize shieldSize size) ) {
			if ( defined $nodeRules{ $r }{ $p } ) {
				if ( grep /:/, $nodeRules{ $r }{ $p } ) {
					my $old = $nodeRules{ $r }{ $p } ;
					my $new = scaleSize ($nodeRules{ $r }{ $p }, $nodeRules{ $r }{ 'fromscale' }, $nodeRules{ $r }{ 'toscale' }) ;
					$nodeRules{ $r }{ $p } = $new ;
					if ( cv('debug') eq "1" ) {
						print "RULES/scale/node: $old -> $new\n" ;
					}
				}
			}
		}
	}
	foreach my $r ( keys %wayRules ) {
		foreach my $p ( qw (bordersize labelsize labeloffset size ) ) {
			if ( defined $wayRules{ $r }{ $p } ) {
				if ( grep /:/, $wayRules{ $r }{ $p } ) {
					my $kv = $wayRules{ $r }{ 'keyvalue' } ;
					my $old = $wayRules{ $r }{ $p } ;
					my $new = 0 ;
					$new = scaleSize ($wayRules{ $r }{ $p }, $wayRules{ $r }{ 'fromscale' }, $wayRules{ $r }{ 'toscale' }) ;
					$wayRules{ $r }{ $p } = $new ;
					if ( cv('debug') eq "1" ) {
						print "RULES/scale/way: $kv $p $old to $new\n" ;
					}
				}
			}
		}
	}
}

sub scaleSize {
	my ($str, $fromScale, $toScale) = @_ ;
	my @tmp = split /:/, $str ;
	my $lower = $tmp[0] ;
	my $upper = $tmp[1] ;
	my $newSize = 0 ;

	my $scale = getScale() ;
	if ( cv('rulescaleset') ne "0" ) { $scale = cv('rulescaleset') } ;

	if ( $scale < $fromScale) {
		$newSize = $upper ;
	}
	elsif ( $scale > $toScale ) {
		$newSize = $lower ;
	}
	else {
		my $percent = ( $scale - $fromScale ) / ($toScale - $fromScale) ;
		$newSize = $upper - $percent * ($upper - $lower) ;
	}
	$newSize = int ( $newSize * 10 ) / 10 ;
	return $newSize ;
}

sub createLegend {

	# TODO Auto size

	my $nx = 80 ;
	my $ny = 80 ;
	my $ey = 1.5 * $ny ;
	my $sx = 700 ;
	my $tx = 200 ;
	my $ty = $ey / 2 ;
	my $fs = 40 ;
	my $actualLine = 0 ;

	my $preCount = 0 ;
	foreach my $n (keys %nodeRules) {
		if ( $nodeRules{$n}{"legend"} eq "yes" ) { $preCount++ ; }
	}
	foreach my $n (keys %wayRules) {
		if ( $wayRules{$n}{"legend"} eq "yes" ) { $preCount++ ; }
	}
	foreach my $n (keys %areaRules) {
		if ( $areaRules{$n}{"legend"} eq "yes" ) { $preCount++ ; }
	}
	if ( cv('debug') eq "1" ) { print "LEGEND: $preCount elements found\n" ; }

	my $sy = $preCount * $ey ;
	addToLayer ("definitions", "<g id=\"legenddef\" width=\"$sx\" height=\"$sy\" >") ;

	my $color = "white" ;
	my $svgString = "fill=\"$color\"" ;
	drawRect (0, 0, $sx, $sy, 0, $svgString, "definitions") ;

	foreach my $n (keys %nodeRules) {
		if ( $nodeRules{$n}{"legend"} eq "yes" ) {
			my $x = $nx ;
			my $y = $actualLine * $ey + $ny ;
			
			if ( ($nodeRules{$n}{'size'} > 0) and ($nodeRules{$n}{'icon'} eq "none") )  {
				my $svgString = "" ;
				if ( $nodeRules{$n}{'svgstring'} ne "" ) {
					$svgString = $nodeRules{$n}{'svgstring'} ;
				}
				else {
					$svgString = "fill=\"$nodeRules{$n}{'color'}\"" ;
				}

				if ( $nodeRules{$n}{'shape'} eq "circle") {
					drawCircle ($x, $y, 0, $nodeRules{$n}{'size'}, 0, $svgString, 'definitions') ;
				}
				elsif ( $nodeRules{$n}{'shape'} eq "square") {
					drawSquare ($x, $y, 0, $nodeRules{$n}{'size'}, 0, $svgString, 'definitions') ;
				}
				elsif ( $nodeRules{$n}{'shape'} eq "triangle") {
					drawTriangle ($x, $y, 0, $nodeRules{$n}{'size'}, 0, $svgString, 'definitions') ;
				}
				elsif ( $nodeRules{$n}{'shape'} eq "diamond") {
					drawDiamond ($x, $y, 0, $nodeRules{$n}{'size'}, 0, $svgString, 'definitions') ;
				}

				my $textSvgString = createTextSVG ( cv('elementFontFamily'), cv('elementFont'), $fs, "black", undef, undef ) ;
				drawText ($tx, ($actualLine+0.5) * $ey + $fs/2, 0, $nodeRules{$n}{'legendlabel'}, $textSvgString, "definitions") ;
			}
			else {
				# TODO icon
			}
		$actualLine ++ ;
		}
	}

	foreach my $w (keys %wayRules) {
		if ( $wayRules{$w}{"legend"} eq "yes" ) {
			my ($x1, $x2) ;
			$x1 = 0.5 * $nx ;
			$x2 = 1.5 * $nx ;
			my $y = $actualLine * $ey + $ny ;
			my ($svg1, $layer1, $svg2, $layer2) = mwWays::createWayParameters ($wayRules{$w}, 0, 0, 0) ;
			my @coords = ($x1, $y, $x2, $y) ;
			if ($svg2 ne "") {
				drawWay ( \@coords, 0, $svg2, "definitions", undef ) ;
			}
			drawWay ( \@coords, 0, $svg1, "definitions", undef ) ;

			my $textSvgString = createTextSVG ( cv('elementFontFamily'), cv('elementFont'), $fs, "black", undef, undef ) ;
			drawText ($tx, ($actualLine+0.5)*$ey + $fs/2, 0, $wayRules{$w}{'legendlabel'}, $textSvgString, "definitions") ;

			$actualLine++ ;

		}
	}

	foreach my $a (keys %areaRules) {
		if ( $areaRules{$a}{"legend"} eq "yes" ) {
			my ($x1, $x2) ;
			my ($y1, $y2) ;
			$x1 = 0.7 * $nx ;
			$x2 = 1.3 * $nx ;
			$y1 = $actualLine * $ey + 0.7 * $ny ;
			$y2 = $actualLine * $ey + 1.3 * $ny ;

			my $color = $areaRules{$a}{'color'} ;
			my $icon = $areaRules{$a}{'icon'} ;
			my $base = $areaRules{$a}{'base'} ;
			my $svgString = $areaRules{$a}{'svgstring'} ;

			if ( ($svgString eq "") and ($icon eq "none") ) {
				$svgString = "fill=\"$color\" " ;
			}

			my @coords = ([$x1, $y1, $x2, $y1, $x2, $y2, $x1, $y2, $x1, $y1]) ;
			drawArea ($svgString, $icon, \@coords, 0, "definitions") ;

			my $textSvgString = createTextSVG ( cv('elementFontFamily'), cv('elementFont'), $fs, "black", undef, undef ) ;
			drawText ($tx, ($actualLine+0.5)*$ey + $fs/2, 0, $areaRules{$a}{'legendlabel'}, $textSvgString, "definitions") ;
			$actualLine++ ;
		}
	}


	addToLayer ("definitions", "</g>") ;

	my $posX = 0 ;
	my $posY = 0 ;

	my ($sizeX, $sizeY) = getDimensions() ;

	if ( cv('legend') eq "2") {
		$posX = $sizeX - $sx ;
		$posY = 0 ;
	}

	if ( cv('legend') eq "3") {
		$posX = 0 ;
		$posY = $sizeY - $sy ;
	}

	if ( cv('legend') eq "4") {
		$posX = $sizeX - $sx ;
		$posY = $sizeY - $sy ;
	}

	if ( (cv('legend') >=1) and (cv('legend')<=4) ) {
		addToLayer ("legend", "<use x=\"$posX\" y=\"$posY\" xlink:href=\"#legenddef\" />") ;
	}
	elsif (cv('legend') == 5) {
		# separate file
		createLegendFile($sx, $sy, "_legend", "#legenddef") ;
	}

}

1 ;