# Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "Symbian Foundation License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

# Package:      DrawSvg

# Build the SVG diagram

# 

#

package DrawSvg;

use Cwd;

use Cwd 'abs_path';

use File::Copy;

use File::Path;

use FindBin;

use lib $FindBin::Bin."/../common";

use Getopt::Long qw(:config no_ignore_case);

use File::Basename;

use File::Spec;

use constant KNoCoreOs					=> 0;

use constant KCoreOsWithHal			=> 1;

use constant KCoreOsWithHardware	=> 2;

use constant KOldSystemModelGenerator							=> 202;

my @Filters;

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

# Subroutine:   new

# Purpose:      

# Input:        None (extracted from command line args)

# Output:       A reference to itself

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

sub new

	{

    my $package = shift;

    my $self = {};              # Create reference to object

    bless $self,  $package;    # Associate a reference with class name

    $self->{iScriptCode} = 999;

    # basic test of command line:

    if (scalar(@ARGV) == 0)

    	{

		$self->Help();

        exit Logger::KErrorNone;	# nothing to do. Leave

    	}

    # process the input:

    $self->ParseCommandLineOptions();

    $self->{iReturnCode} = Logger::KErrorNone;

    return $self;

	}

# gets the schema versions without comsuming any of the command line arguments

sub SchemaVersionsFromArgs

	{ 

	my @sysdefs;

	my @ini;

	my $model;

	for(my $i=0;$i<=$#_;$i++)

		{

		if($_[$i] eq '-model')

			{

			$model=$_[++$i];

			}

		if($_[$i] eq '-sysdef')

			{

			$i++;

			push(@sysdefs,split(/,/,$_[$i]));

			}

		elsif($_[$i] eq '-i')

			{

			push(@ini,$_[++$i]);

			}

		}

	if(!scalar(@sysdefs) )

		{

		foreach my $in (@ini)

			{

			open(INI,$in);

			my $iniDir = $in;

			$iniDir =~ s,[^\\//]+$,,;

			while(my $line = <INI>)

				{

				$line =~ s/^\s*//; 		# remove spaces

				$line =~ s/\s*$//;		# a/a

				$line =~ s/\n$//; 		# remove new line

				if($line =~/"/) {

					$line =~ s/^(([^"#]*"[^"]*")+)#.*$/$1/; 		# remove comments indicated by # (to the end of the line)

				}  else {

					$line =~ s/#.*$//; 		# remove comments indicated by # (to the end of the line)

				}

				next if $line eq ""; 	# ignore blank lines

				if ($line =~ m/sysdef\s*=\s*(.*)/i)

					{

					foreach my $file (split(/,/,$1))

						{

						push(@sysdefs,&FullPath($iniDir,$file));

						}

					}

				}

			close INI;

			}

		}

	my $dir = $model;

	$dir=~s,[^/\\]+$,,;

	open M,$model;

	$/=">";

	while(my $line=<M>)

		{

		if($line=~s/<sysdef.*href=("[^"]+"|'[^']+')//)

			{

			my $f=$1;

			$f=~s/^.(.*).$/$1/;

			if(! ($f=~/^(\/|[a-z]+:)/)) {$f="$dir$f"}

			push(@sysdefs,$f);

			}

		}

	close M;

	my %res;

	foreach my $file (@sysdefs)

		{

		open S,$file;

		while(my $line = <S>)

			{

			if($line =~ /<SystemDefinition.*\sschema="(.*?)"/s)

				{

				push(@{$res{$1}},$file);

				last;

				}

			}

		close S;

		}

	$/="\n";

	return %res;

	}

sub GuessReleaseNumber()

	{

	my $self = shift;	

	# always use release value if defined

	$self->{iRelease} && return $self->{iRelease} ;

	# if not there, it's in the s12,

	my $ver;

	my $t = $/;

	foreach my $s12 (@{$self->{'iS12'}})		# use version from first s12 file listed

		{

		if(-d $s12) {next}

		open(FILE,$s12) || return;

		$/='>';

		while(<FILE>)

			{

			if(/<Schedule12\s.*\bOS_version=('(.*?)'|"(.*?)")/s)

				{

				$ver = $2 || $3;

				last;

				}

			}

		close FILE;

		$/=$t;

		return  $ver;

		}

	# not there either, 

	if($self->{'iDepsFile'}) 

		{

		open(FILE,$self->{'iDepsFile'}) || return;

		$/='>';

		while(<FILE>)

			{

			if(/<SystemModelDeps\s.*\bversion=('(.*?)'|"(.*?)")/s)

				{

				$ver = $2 || $3;

				last;

				}

			}

		close FILE;

		$/=$t;

		return  $ver;

		}

	return "";

	}

# an empty value indicates its a single file. Any other value means it's a list separated by that value as a regexp

%KFileParams = 

	( 

	'iSysDefFile'	=> ',',

	'iS12'		=> ',',

	'iExtra'		=> ',',

	'iDepsFile'	=> '',

	'iLocalize'		=> ',',

	'iLevels'		=> ',',

	'iStyle'		=> ',',

	'iOverlay'		=> ',',

	'iBorder'		=> ',',

	'iColor'		=> ',',

	'iShapes'		=> '',

	'iLogoSrc'		=> '',

	'iModel'		=> '',

	'iLogFile'		=> '',

	);

sub ParseCommandLineOptions()

	{

	my $self = shift;

	# Possible arguments (with default values where possible):

	my $help;

	$self->{iSysDefFile};

	$self->{iDepsFile};

	$self->{iOutputCsv};

	$self->{iCsvColumns};

	$self->{iCsvLabels};

	$self->{iTemporaryDirectory};

	$self->{iLogFile};

	$self->{iWarningLevel};

	$self->{iClean}; # if specified, it will delete the temp directory.

	# custom properties:

	$self->{iDiagram}; # the output svg

	$self->{iCopyright};

	$self->{iRelease};

	$self->{iName};

	$self->{iLabel};

	$self->{iModel};

	$self->{iCoreOs};

	$self->{iLevels};

	$self->{iExtra};

	$self->{iIniFile};

	$self->{iS12};

	$self->{iLink};

	# Read in the user arguments:

	GetOptions( "h"						=> \$help,

				"i=s"					=> \$self->{iIniFile},

				"output=s"				=> \$self->{iDiagram} ,

				"csv_output=s"				=> \$self->{iOutputCsv} ,

				"csv_columns=s"				=> \$self->{iCsvColumns} ,

				"csv_labels=s"				=> \$self->{iCsvLabels} ,

				'xml_output=s'				=> \$self->{iOutputXml} ,

				"model=s"				=> \$self->{iModel} ,

				"sysdef=s"				=> \@{$self->{iSysDefFile}} ,

				"srcvar=s"				=> \@{$self->{iSourceRoot}} ,

				"shapes=s"				=> \$self->{iShapes},

				"link=s"				=> \$self->{iLink},

				"system_name=s"			=> \$self->{iName} ,

				"system_version=s"		=> \$self->{iRelease} ,

				"model_name=s"			=> \$self->{iLabel} ,

				"model_version=s"		=> \$self->{iRevision},

				"model_version_type=s"	=> \$self->{iRevisionType},

				"copyright=s"			=> \$self->{iCopyright},

				"distribution=s"		=> \$self->{iDistribution},

				"legend_title=s"		=> \$self->{iLgdTitle},

				"coreos=s"				=> \$self->{iCoreOs},

				"sysinfo=s"				=> \@{$self->{iExtra}},

				"localize=s"			=> \@{$self->{iLocalize}},

				"levels=s"				=> \@{$self->{iLevels}},

				"color=s"				=> \@{$self->{iColor}},

				"border-shape=s"		=> \@{$self->{iBorder}},

				"pattern=s"				=> \@{$self->{iOverlay}},

				"border-style=s"		=> \@{$self->{iStyle}},

				"filter=s"				=> \@{$self->{iFilter}},

				"filter-has=s"				=> \&OrderedOption,

				"show-attr=s"			=> \&OrderedOption,

				"hide-attr=s"			=> \&OrderedOption,

				"ignore=s"				=> \@{$self->{iIgnore}},

				"s12=s"				=>  \@{$self->{iS12}},

				"detail=s"				=> \$self->{iDetail},

				"detail-type=s"				=> \$self->{iDetailType},

				"page-width=s"			=> \$self->{iPageWidth},

				"static"				=> \$self->{iStatic},

				"deps=s"				=> \$self->{iDepsFile},

				"w=s"					=> \$self->{iWarningLevel},

				"clean"				=> \$self->{iClean},				

				"compress"				=> \$self->{iCompress},

				"tempdir=s"				=> \$self->{iTemporaryDirectory},

				"dpi=s"				=> \$self->{iPrintResolution},

				"model_font=s"				=> \$self->{iModelFont},

				"version-list=s"			=>  \$self->{iVersions},

				"log=s"				=> \$self->{iLogFile},

				"logo=s"				=> \$self->{iLogoSrc},

				"logo-height=s"				=> \$self->{iLogoHeight},

				"logo-width=s"				=> \$self->{iLogoWidth},

				"legend-width=s"			=> \$self->{iLegendWidth},

				"legend-max-scale=s"			=> \$self->{iLegendMaxScale},

				"title-scale=s"			=> \$self->{iTitleScale},

				"xslt-param=s"			=> \%{$self->{iXsltParam}},

				"note=s"			=> \@{$self->{iLegendNote}}

				);

	if ($help)

	    {

	   	warn $self->Help();

	   	exit Logger::KErrorNone;

	   	}

	@{$self->{'iFiltering'}} = @Filters;

	@Filters=();

	my $i=0;

	for($i=0;$i<=$#ARGV;$i++)

		{ # check remaining args to ensure they are valid

			if($ARGV[$i]=~/^(http|file):\/\//) { # assume URLs are correct

				next;			

				}

			if($ARGV[$i] eq "-" || $ARGV[$i] eq "") 

				{ #special values to use nothing or use the tmp file, but only valid for odd numbered args

				if($i%2==1) {next}

				$self->Help();

				&Logger::LogFatal("Invalid syntax", KOldSystemModelGenerator, 0,Logger::KIncorrectSyntax);

				}

			if(!(-e $ARGV[$i])) {

				warn "file $ARGV[$i] does not exist";

	   			exit Logger::KFileDoesNotExist;

			}

		}

	# Now read the ini file and override command line if necessary:

	my @yr = gmtime();

	my $dataroot =&SystemModelXmlDataDir();

	my %defaults = (

		'iCopyright' 			=> (1900+$yr[5])." Nokia Corporation",

		'iDiagram' 			=> "sysmodel.svg",

		'iTemporaryDirectory' 	=> "drawsvg_temp",

		'iName' 				=> "Symbian OS"	,

		'iLabel' 				=> "System Model",

		'iLgdTitle' 				=> "Key",

		'iShapes' 				=> "$dataroot/Shapes.xml" 	,

		'iLogFile' 				=> ""  # do not set this to any default: stdout is used if log file isn't set

	);

	my %defaultsForMulti = (

		'iLocalize' 			=> "$dataroot/display-names.xml" ,

		'iExtra' 				=> "$dataroot/SystemInfo.xml"   

	);

	$self->ReadIniFile();

	foreach my $type ('iSysDefFile', 'iFilter','iSourceRoot')

		{

		if(scalar(@{$self->{$type}})==1 && $self->{$type}->[0]=~/,/)

			{ # treat as comma-separated for backwards compatibility (leave alone if no commas)

			@{$self->{$type}} = split(/,/,$self->{$type}->[0]);

			}

		}

	if (scalar(@{$self->{iIgnore}})) 

		{

		foreach my $type ('iIgnore')

			{

			if(scalar(@{$self->{$type}})==1)

				{ # treat as semicolon-separated for backwards compatibility

				@{$self->{$type}} = split(/;/,$self->{$type}->[0]);

				}

			}

		}

	else

		{

		push(@{$self->{iIgnore}}, "layer:Tools and Utils and SDKENG","layer:MISC","block:Techview") 

		}

	my $ver = $self->GuessReleaseNumber(); # determine release from attached files.

	# Use a special levels.xml file for 9.1 (unless it's specified by the user):

	push(@{$self->{iLevels}}, "$dataroot/Levels91.xml") if !scalar(@{$self->{iLevels}}) and $ver eq "9.1";

	push(@{$self->{iLevels}}, "$dataroot/Levels.xml") if !scalar(@{$self->{iLevels}}) and ($ver eq "9.2" or $ver eq "9.2" );

	if(!scalar(@{$self->{'iFiltering'}}) && !scalar(@{$self->{'iFilter'}}))

		{ # filter only has a default if fitler-has is not set

		@{$self->{'iFilter'}}= ("java","gt");

		}

	while (($key, $value) = each %defaults) {

		$self->{$key} = $value if ! defined $self->{$key};

	}

	while (($key, $value) = each %defaultsForMulti) {

		push(@{$self->{$key}}, $value) if ! scalar(@{$self->{$key}});

	}

	# if saving to .svgz, try to compress

	$self->{iCompress} = $self->{iCompress} || ( $self->{iDiagram} =~ /\.svgz$/i );

	# if there's a deps file XSLT will get revision number and type from that.

	# if there is no deps file and neither revision nor revision type are specified, default to "DRAFT 1"

	if(!$self->{'iDepsFile'} &&  !$self->{'iRevision'} && !$self->{'iRevisionType'})

		{

		$self->{'iRevisionType'} = "draft";

		$self->{'iRevision'} = "1";

		}

	if ($self->{iShapes} eq "$dataroot/Shapes.xml"  && !scalar(@{$self->{'iColor'}}))

		{ # if it's got the default shapes use default colours

		@{$self->{iColor}} = (&SystemModelColorsXmlFile());

		}

	if(defined $self->{iCoreOs})

		{

		if($self->{iCoreOs}=~/(on|yes|true)$/i )

			{

			$self->{iCoreOs} = KCoreOsWithHal;

			}

		elsif($self->{iCoreOs}=~/(off|no|false)$/i )

			{

			$self->{iCoreOs} = KNoCoreOs;

			}

		elsif(! ($self->{iCoreOs}=~/^[0-9]+$/ ))	# any other non-number

			{

			$self->{iCoreOs} = KCoreOsWithHardware;

			}

		}

	else		# use version numebr to decide

		{

		$self->{iCoreOs} = ($self->{iRelease} eq 'Future' || $ver > 9.4) ? KCoreOsWithHardware :

			(($ver=~/^9\.4/) ? KCoreOsWithHal : KNoCoreOs);

	}

	$self->{'iGuessVer'} = $ver;

	mkpath $self->{iTemporaryDirectory} if ! -d $self->{iTemporaryDirectory};

	# set the log file if needed:

	$Logger::LOGFILE = $self->{iLogFile} if $self->{iLogFile};

	# set the correct warning level:

	#  -w=1: errors only (default)

	#  -w=2: warnings as well as errors

	#  -w=3: info messages, warnings and errors.

	if (defined $self->{iWarningLevel} and $self->{iWarningLevel} > 1)

		{

		if ($self->{iWarningLevel} == 2)

			{

			$self->{iWarningLevel} = LogItem::WARNING;

			}

		elsif ($self->{iWarningLevel} == 3)

			{

			$self->{iWarningLevel} = LogItem::INFO;

			}

		else # for anything higher than set it to LogItem::VERBOSE

			{

			$self->{iWarningLevel} = LogItem::VERBOSE;

			}

		}

	else

		{

		$self->{iWarningLevel} = LogItem::ERROR;

		}

	# set the logger up:

	$Logger::SEVERITY = $self->{iWarningLevel};

	# set all URIs

	(my $dir  = cwd ) =~ s#\/#\\#g;

	foreach ( keys(%KFileParams)) {

		if($self->{$_} eq '') {next} # no value, so do nothing

		if($KFileParams{$_} eq '') {

			$self->{$_}  = &FullPath("$dir\\",	$self->{$_} );

		} elsif($KFileParams{$_} eq ',') {

			foreach my $item  (@{$self->{$_}})	{

				if ($item eq '') {next}	# skip if explicitly set to empty

				$item = &FileAsUrl(&FullPath("$dir\\",$item));

			}

			next;

		} 

		$self->{$_} = &FileAsUrl($self->{$_});

	}	

}

sub OrderedOption() {

	my $var = shift;

	my $val = shift;

	if($var=~/^(show|hide)-attr$/) {

		my $f = "<filter display='$1' ";

		if($val=~s/^([^=]+)=//) {$f.="select='$1' value='$val'/>"}

		else {$f.="select='$val'/>"}

		push(@Filters,$f);

	} elsif($var eq 'filter-has' && $val eq '*') {

		push(@Filters,"<filter display='show' select='*'/>");

	}elsif($var eq 'filter-has') {

		if(!scalar(@Filters)) { # if the 1st is showing a filter than that implies everythig without a filter is turned off 

			push(@Filters,'<filter select="*" display="hide"/>');

		}

		foreach my $v (split(/,/,$val)) {

			push(@Filters,"<filter display='show' select='filter' value='$v'/>");

		}

	}

}

sub FullPath {

	my $root = shift;

	my $file = shift;

	# If the file is not specified then return null

	if (!$file) {

		return;

	}

	# If the file is a URL or Windows path then return it as is

	if ($file =~ /:/) {

		return $file;

	}

	if ($root && !-e $root) {

		&Logger::LogFatal("root $root does not exist");