# Copyright (c) 2010 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:

#

#!/usr/bin/perl

use strict;

use FindBin;		# for FindBin::Bin

use lib $FindBin::Bin;

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

use Cwd;

use Cwd 'abs_path';

use Getopt::Long;

use File::Basename;

use File::Spec;

use XML::DOM;

my $output;

my $path;

my @config;

my @includes;

my %defineParams;

my %defines;

my $defaultns = 'http://www.symbian.org/system-definition';	# needed if no DTD

my @excludeMetaList;

my @cannotExclude= ('link-mapping', 'config');

my %ID;	# list of all IDs

my $errCount=0;

my @newarg;

foreach my $a (@ARGV)

	{ #extract all -I parameters from the parameter list 

	if($a=~s/^-I//)

		{

		push(@includes,$a);

		}

	else

		{

		push(@newarg,$a);

		}

	}

@ARGV=@newarg;

# need to add options for controlling which metas are filtered out and which are included inline

GetOptions

	(

	 'path=s' => \$path,

	'output=s' => \$output,

	'config=s' => \@config,

	'exclude-meta=s' => \@excludeMetaList

	);

# -path specifies the full system-model path to the file which is being processed. 

#	This must be an absolute path if you're processing a root sysdef.

#	If processing a pkgdef file, you can use "./package_definition.xml" to leave all links relative. Though I can't really see the use case for this.

# -output specifies the file to save the output to. If not specified this will write to stdout

# -config specifies the name of an .hrh file in which the configuration data is acquired from. If not set, no confguration will be done.

# -I[path] specifies the include paths to use when resolving #includes in the .hrh file. Same syntax as cpp command uses. Any number of these can be provided.

# if config is not set, no confguration will be done.

# If it is set, all configuration metadata will be processed and stripped from the output, even if the confguration data is empty

 if($path eq '') {$path = '/os/deviceplatformrelease/foundation_system/system_model/system_definition.xml'}

($#ARGV == -1 ) && &help();

my $sysdef = &abspath(shift);	# resolve the location of the root sysdef

my %excludeMeta;

foreach (@excludeMetaList) {$excludeMeta{$_}=1}	# make list a hash table

foreach (@cannotExclude)

	{

	if($excludeMeta{$_})

		{

		print STDERR "Error: Cannot exclude meta rel=\"$_\"\n";

		$errCount++;

		}

	$excludeMeta{$_}=0

	}	# cannot exclude any of these rel types

# rootmap is a mapping from the filesystem to the paths in the doc

my %rootmap = &rootMap($path,$sysdef);	

my %nsmap;

my %urimap;

foreach my $conf (@config) 

	{ # run cpp to get all #defines

	&getDefines($conf);

	}

my $parser = new XML::DOM::Parser;

my   $sysdefdoc = $parser->parsefile ($sysdef);

my $maxschema = $sysdefdoc->getDocumentElement()->getAttribute('schema');	# don't check value, just store it.

# find all the namespaces used in all trhe fragments and use that 

# to set the namespaces ni the root element of the created doc

#   should be able to optimise by only parsing each doc once and 

#	maybe skipping the contends of <meta>

my @nslist = &namespaces($sysdef,$sysdefdoc->getDocumentElement());

while(@nslist)

	{

	my $uri = shift(@nslist);

	my $prefix =shift(@nslist);

	if($prefix eq 'id namespace'){$prefix=''}

	if(defined $urimap{$uri}) {next} # already done this uri

	$urimap{$uri} = $prefix;

	if($nsmap{$prefix})

		{ # need a new prefix for this, guess from the URI (for readability)

		if($uri=~/http:\/\/(www\.)?([^.\/]+)\./) {$prefix = $2}

		my $i=0;

		while($nsmap{$prefix})

			{ # still no prefix, just make up 

			$prefix="ns$i";

			$i++;

			# next line not really necessary, but it's a good safety to stop infinite loops

			$i eq 1000 && die "cannot create namespace prefix for $uri";

			}

		}

	$nsmap{$prefix}=$uri;

	}

my $docroot =  $sysdefdoc->getDocumentElement;

my $ns = $docroot->getAttribute('id-namespace');

if(!$ns && $nsmap{''})

	{

	$docroot->setAttribute('id-namespace',$nsmap{''});

	}

$docroot->setAttribute('schema',$maxschema);	# output has the largest syntax version of all includes

while(my($pre,$uri) = each(%nsmap))

	{

	$pre ne '' || next ;

	$docroot->setAttribute("xmlns:$pre",$uri);

	}

&walk($sysdef,$docroot);	# process the XML

# print to file or stdout

if($output eq '') 

	{

	print $sysdefdoc->toString;

	}

else

	{

	$sysdefdoc->printToFile($output);

	}

$errCount && die "Fatal syntax errors";

sub abspath

	{ 	# normalize the path into an absolute one

	my  ($name,$path) = fileparse($_[0]);

	$path=~tr,\\,/,;

	if( -e $path)

		{

		return abs_path($path)."/$name";

		}

	my @dir = split('/',$_[0]);

	my @new;

	foreach my $d (@dir)

		{

		if($d eq '.') {next}

		if($d eq '..')

			{

			pop(@new);

			next;

			}

		push(@new,$d)

		}

	return join('/',@new);

	}

sub rootMap {

	my @pathdirs = split(/\//,$_[0]);

	my @rootdirs = split(/\//,$_[1]);

	while(lc($rootdirs[$#rootdirs])  eq lc($pathdirs[$#pathdirs])  )

		{

		pop(@rootdirs);

		pop(@pathdirs);

		}

	return (join('/',@rootdirs)  => join('/',@pathdirs) );

	}

sub rootMapMeta {

	# find all the explict path mapping from the link-mapping metadata

	my $node = shift;

	foreach my $child (@{$node->getChildNodes})

			{

			if ($child->getNodeType==1 && $child->getTagName eq 'map-prefix')

				{

				my $from = $child->getAttribute('link');

				my $to = $child->getAttribute('to');		# optional, but blank if not set

				$rootmap{$from} = $to;

				}

			}

	# once this is processed we have no more need for it. Remove from output

	$node->getParentNode->removeChild($node);

	}

sub walk

	{ 	# walk through the doc, resolving all links

	my $file = shift;

	my $node = shift;

	my $type = $node->getNodeType;

	if($type!=1) {return}

	my $tag = $node->getTagName;

	if($tag=~/^(layer|package|collection|component)$/ )

		{

		if($file eq $sysdef)

			{

			&fixIDs($node);	# normalise all IDs in the root doc. Child docs are handled elsewhere.

			}

		my $link= $node->getAttribute('href');

		if($link)

			{

			my $file = &resolvePath($file,$link); 

			if(-e $file)

				{

				&combineLink($node,$file);

				}

			else

				{

				print STDERR "Note: $file not found\n";

				$node->removeAttribute('href');

				}

			return;

			}

		else 

			{ # only check for duplicate IDs on the implementation

			my $id= $node->getAttribute('id');

			my $p = $node->getParentNode();

			my $ptext = $p->getTagName()." \"".$p->getAttribute('id')."\"";

			if(defined $ID{$id})

				{

				print STDERR "Error: duplicate ID: $tag \"$id\" in $ptext matches $ID{$id}\n";

				$errCount++;

				}

			else 

				{

				my $p = $node->getParentNode();

				$ID{$id}="$tag in $ptext";

				}

			}

		}

	elsif($tag=~/^(SystemDefinition|systemModel)$/ )

		{

		}

	elsif($tag eq 'unit')

		{

		foreach my $atr ('bldFile','mrp','base')

			{

			my $link= $node->getAttribute($atr);

			if($link && !($link=~/^\//))

				{

				$link= &abspath(File::Basename::dirname($file)."/$link");

				foreach my $a (sort {length($b) - length($a)} keys(%rootmap)) {

					$link=~s,^$a,$rootmap{$a},ie;

				}

				# remove leading ./  which is used to indicate that paths should remain relative

				$link=~s,^\./([^/]),$1,; 

				# remove windows drive letter -- only allow paths on the same drive. Use root attribuite to build across drives / filesystems

				$link=~s,^[a-z]:/,/,i;	

				$node->setAttribute($atr,$link);

				}

			}

		if(scalar @{$node->getChildNodes()} && $maxschema=~/^3\.0/)

			{

			die "Error: Fatal syntax error in $file. Unit elements must be empty in schema $maxschema.\n";

			}

		}

	elsif($tag eq 'meta')

		{

		my $rel= $node->getAttribute('rel') || 'Generic';

		if($excludeMeta{$rel})

			{

			$node->getParentNode->removeChild($node);

			return;

			}

		my $link= $node->getAttribute('href');

		$link=~s,^file://(/([a-z]:/))?,$2,; # convert file URI to absolute path

		if ($link ne '' ) 

			{ 

			if($link=~/^[\/]+:/)

				{

				print STDERR "Note: Remote URL $link not embedded\n";

				next; # do not alter children

				}

			if(! ($link=~/^\//))

				{

				$link= &abspath(File::Basename::dirname($file)."/$link");

				}

			if(! -e $link) 

				{

				print STDERR "Warning: Local metadata file not found: $link\n";

				next; # do not alter children

				}

			# if we're here we can just embed the file

			# no processing logic is done! It's just embedded blindly

			my $item;

			eval {

				my  $metadoc = $parser->parsefile ($link);

				$item = $metadoc->getDocumentElement;

			};

			if(!$item)

				{

				print STDERR "Error: Could not process metadata file: $link\n";

				$errCount++;

				next; # do not alter children

				}

			$node->removeAttribute('href');

			&blindCopyInto($node,$item);

			}

		if($node->getAttribute('rel') eq 'link-mapping')

			{# need to process this now

			&rootMapMeta($node);

			}

		return;

		}

	else {return}

	my $checkversion=0;

	foreach my $item (@{$node->getChildNodes})

		{

		#print $item->getNodeType,"\n";

		&walk($file,$item);

		$checkversion = $checkversion  || ($tag eq 'component' &&  $item->getNodeType==1 && $item->getAttribute('version') ne '');

		}

	if($checkversion && scalar(@config))

		{ # need to check the conf metadata on the units in this component

		&doCmpConfig($node);

		}

	foreach my $item (@{$node->getChildNodes})

		{

		if ($item->getNodeType==1 && $item->getTagName eq 'meta')

			{

			&processMeta($item);

			}

		}

	}

sub combineLink

	{

	# combine data from linked sysdef fragment w/ equivalent element in parent document

	my $node = shift;

	my $file = shift;

	my $getfromfile = &localfile($file);

	$getfromfile eq '' && return;  # already raised warning, no need to repeat

	my  $doc = $parser->parsefile ($getfromfile);

	my $item =&firstElement($doc->getDocumentElement);

	$item || die "badly formatted $file";	

	&fixIDs($item);

	my %up = &atts($node);

	my %down = &atts($item);

	$up{'id'} eq $down{'id'}  || die "$up{id} differs from $down{id}";

	$node->removeAttribute('href');

	foreach my $v (keys %up) {delete $down{$v}}

	foreach my $v (keys %down)

		{

		$node->setAttribute($v,$down{$v})

		}

	foreach my $child (@{$item->getChildNodes})

		{

		&copyInto($node,$child);

		}

	&walk($file,$node);

	}

sub blindCopyInto

	{

	# make a deep copy the node (2nd arg) into the element (1st arg)

	my $parent=shift;

	my $item = shift;

	my $doc = $parent->getOwnerDocument;

	my $type = $item->getNodeType;

	my $new;

	if($type==1) 

		{

		$new = $doc->createElement($item->getTagName);

		my %down = &atts($item);

		while(my($a,$b) = each(%down))

			{

			$new->setAttribute($a,$b);

			}

		foreach my $child (@{$item->getChildNodes})

			{

			&blindCopyInto($new,$child);

			}

		}

	elsif($type==3) 

		{

		$new = $doc->createTextNode ($item->getData);

		}

	elsif($type==8) 

		{

		$new = $doc->createComment  ($item->getData);

		}

	if($new)

		{

		$parent->appendChild($new);

		}

	}

sub copyInto

	{

	# make a deep copy the node (2nd arg) into the element (1st arg)

	my $parent=shift;

	my $item = shift;

	my $doc = $parent->getOwnerDocument;

	my $type = $item->getNodeType;

	my $new;

	if($type==1) 

		{

		&fixIDs($item);

		$new = $doc->createElement($item->getTagName);

		my %down = &atts($item);

		foreach my $ordered ('id','name','bldFile','mrp','level','levels','introduced','deprecated','filter')

			{

			if($down{$ordered})

				{

				$new->setAttribute($ordered,$down{$ordered});

				delete $down{$ordered}

				}

			}

		while(my($a,$b) = each(%down))

			{

			$new->setAttribute($a,$b);

			}

		foreach my $child (@{$item->getChildNodes})

			{

			&copyInto($new,$child);

			}

		}

	elsif($type==3) 

		{

		$new = $doc->createTextNode ($item->getData);

		}

	elsif($type==8) 

		{

		$new = $doc->createComment  ($item->getData);

		}

	if($new)

		{

		$parent->appendChild($new);

		}

	}

sub getNs

	{

	# find the namespace URI that applies to the specified prefix.

	my $node = shift;

	my $pre = shift;

	my $uri = $node->getAttribute("xmlns:$pre");

	if($uri) {return $uri}

	my $parent = $node->getParentNode;

	if($parent && $parent->getNodeType==1)

		{

		return getNs($parent,$pre);

		}

	}

sub fixIDs

	{

	# translate the ID to use the root doc's namespaces 

	my $node = shift;

	foreach my $id ('id','before','replace')

		{

		&fixID($node,$id);

		}

}

sub fixID

	{

	# translate the ID to use the root doc's namespaces 

	my $node = shift;

	my $attr = shift || 'id';

	my $id = $node->getAttribute($attr);

	if($id eq '') {return}

	my $ns;

	if($id=~s/^(.*)://)

		{ # it's got a ns, find out what it is

		my $pre = $1;

		$ns=&getNs($node,$pre);

		}

	else

		{

		$ns = $node->getOwnerDocument->getDocumentElement->getAttribute("id-namespace") ||

			$defaultns;

		}

	$ns = $urimap{$ns};

	$id = ($ns eq '') ? $id : "$ns:$id";

	return $node->setAttribute($attr,$id);

}

sub firstElement {