# 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 "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-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 Logger;

use DepConstants;

use constant KNoCoreOs					=> 0;

use constant KCoreOsWithHal			=> 1;

use constant KCoreOsWithHardware	=> 2;

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)

    	{

		warn $self->Help();

        &Logger::LogFatal("Incorrect syntax. Cannot continue...", $self->{iScriptCode});

    	}

    # process the input:

    $self->ParseCommandLineOptions();

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

    return $self;

	}

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},

				"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 DepConstants::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}

				warn "Invalid syntax";

				warn $self->Help();

	   			exit DepConstants::KIncorrectSyntax

				}

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

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

	   			exit DepConstants::KFileDoesNotExist;

			}

		}

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

	my @yr = gmtime();

	my $dataroot =&DepConstants::SystemModelXmlDataDir();

	my %defaults = (

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

		'iDiagram' 			=> "sysmodel.svg",

		'iTemporaryDirectory' 	=> "drawsvg_temp",

		'iName' 				=> "Symbian OS"	,

		'iLabel' 				=> "System Model",

		'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}} = (&DepConstants::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} = DepConstants::WARNING;

			}

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

			{

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

			}

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

			{

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

			}

		}

	else

		{

		$self->{iWarningLevel} = DepConstants::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 does not exist");

	}

	if (-f $root) {

		$root = File::Basename::dirname($root)

	}

	# if root is empty or the same dir, then file is relative

	if($root eq '' or $root eq '.') {

		return $file;

	}	

	# If the file is relative from the root then we want to add the drive letter to the file (if one exists)

	if ($file =~ s/^[\\\/]// ) {

		if ($root =~ /^([a-z]:)/i) {

			return File::Spec->catdir($1, $file);

		}

	}

	# Return the concatenated root and filename

	return File::Spec->catdir($root, $file);

}

sub ReadIniFile()

	{

	my $self = shift;

	return if ! defined $self->{iIniFile};

	# Log a fatal error if the ini file is defined but doesn't exist:

	&Logger::LogFatal("ini file does not exist\"$self->{iIniFile}\": $!", $self->{iScriptCode}) if ! -e $self->{iIniFile};

	open(INI, $self->{iIniFile}) or 

		&Logger::LogFatal("Could not open the ini file \"$self->{iIniFile}\": $!", $self->{iScriptCode});

	&Logger::LogInfo("Reading ini file \"$self->{iIniFile}...", $self->{iScriptCode});

	%AllowMulitples = (

		"iLocalize"		=> 1,

		"iExtra"		=> 1,

		'iLevels'		=> 1,

		'iSysDefFile'		=> 1,

		'iSourceRoot'		=> 1,

		'iS12'		=> 1,

		"iIgnore"		=> 1,

		"iFilter"		=> 1,

		"iStyle"		=> 1,

		"iOverlay"		=> 1,

		"iBorder"		=> 1,

		"iColor"		=> 1,

		"iLegendNote" => 1,

		"iXsltParam" => 2

	); # value of 2 means it's a hash, value of 1 is an array

	foreach my $m (keys %AllowMulitples) {

		# if it's already set, note that we're to ignore anything in the ini file

		if($AllowMulitples{$m}==2 ? (scalar(%{$self->{$m}})>0) : (scalar(@{$self->{$m}})>0)) {$AllowMulitples{$m}=0}

	}

	%Ordered = (

		"filter-has"				=> 1,	

		"show-attr"			=> 1,

		"hide-attr"			=> 1

	);

	%IniMap = (

		"model"					=> 'iModel' ,

		"sysdef"				=> 'iSysDefFile' ,

		'srcvar'					=> 'iSourceRoot',

		"shapes"				=> 'iShapes',

		"system_name"			=> 'iName' ,

		"model_name"			=> 'iLabel' ,

		"system_version"		=> 'iRelease' ,

		"copyright"				=> 'iCopyright',

		"model_version"			=> 'iRevision',

		"model_version_type"	=> 'iRevisionType',

		"distribution"			=> 'iDistribution',

		"coreos"				=> 'iCoreOs',

		"sysinfo"				=> 'iExtra',

		"localize"				=> 'iLocalize',

		"levels"				=> 'iLevels',

		"filter"				=> 'iFilter',

		"ignore"				=> 'iIgnore',

		"output"				=> 'iDiagram',

		"csv_output"				=> 'iOutputCsv',