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

# This package contains routines to read the information from the Component Description Files.
package cdfparser;

# Include Module package to use APIs to parse an XML file.
use genericparser;

require Exporter;
@ISA=qw(Exporter);
@EXPORT=qw(
	CreateCDFFileBinaryMapFromDir
	GetBinaries
	GetCDFFileName
	LoadCDF
	GetDynamicDependencies
	GetBinaryInfo
	GetIncludedFeatureList
	GetExcludedFeatureList
);

use strict;

# Map between the CDF File Name and the corresponding list of binaries
# This is required so that one can fetch the list of binaries for a particular CDF file.
my %binaryCDFFileMap=();

# Include Feature List
# The list of features to be included for a given binary.
my @includeFeatureList;

# Exclude Feature List
# The list of features to be excluded for a given binary.
my @excludeFeatureList;

# List that contains the complete information of each binary
my %binaryInfo=();

my $warning_level = 0;

# Absolute path that contains the CDF Files
my @cdfDirectories;

# To extract the cdf files from the directory specified as input. The default directory is chosen if no 
# input is specified.
sub CreateCDFFileBinaryMapFromDir
{

	my @acdfDirList = @_;
	# To store the list of cdf file names specified under the directory
	my @cdfFileList;

	if ((scalar @acdfDirList) != 0)
	{
		foreach my $acdfDir (@acdfDirList)
		{
			opendir DIR, "$acdfDir";
			if(not grep /$acdfDir/i, @cdfDirectories)
			{
				push @cdfDirectories, $acdfDir;
			}

			push (@cdfFileList, (grep /\.cdf/i, readdir DIR));
			foreach my $filename (@cdfFileList)
			{
				&CreateCDFFileBinaryMap(lc($filename), $acdfDir);
				$binaryCDFFileMap{$filename}{path} = $acdfDir;
			}
		}
	}
}

# To create a mapping between the CDF file name and the corresponding list of binaries
sub CreateCDFFileBinaryMap
{
	my ($cdffilename, $aCdfDir) = @_;

	if( defined $binaryCDFFileMap{$cdffilename} )
	{
		return;
	}

	my $path;
	if( defined $aCdfDir)
	{
		$path = "$aCdfDir\\$cdffilename";
	}
	else
	{
		$path = $cdffilename;
	}

	my $rootNode = &genericparser::getRootElement($path);
	$binaryCDFFileMap{$cdffilename}{root} = $rootNode;

	my @binaryList = &genericparser::getChildElements($rootNode);

	my $binaryInfoRef;
	foreach my $binary (@binaryList)
	{
		my $filename = &genericparser::getAttrValue($binary, "id");
		push @{$binaryCDFFileMap{$cdffilename}{binaries}}, $filename;
# This is required so that one can fetch the CDF file name in which the binary is present
		$binaryInfoRef = \%{$binaryInfo{$filename}};
		$binaryInfoRef->{"filename"} = $cdffilename;
	}
}

# To get the complete list of binaries present in a given CDF file
# Input Parameter : CDF filename
# Returns the complete list of binaries
sub GetBinaries
{
	my $cdffilename = shift;
	if (exists $binaryCDFFileMap{$cdffilename})
	{
		return @{$binaryCDFFileMap{$cdffilename}{binaries}};
	}
	else
	{
		return undef;
	}
}


# To get the name of the CDF file that contains the input binary
# Input Parameter : Binary Name
# Returns the CDF file name
sub GetCDFFileName
{
	my $aBinary = lc(shift);

	if (exists $binaryInfo{$aBinary})
	{
		my $binInfo = \%{$binaryInfo{$aBinary}};
		return $binInfo->{filename};
	}
	else
	{
		return undef;
	}

}

#Loads all the specified CDF files.
sub LoadCDF
{
	my @cdfFileList = @_;

	foreach my $afile (@cdfFileList)
	{
		CreateCDFFileBinaryMap($afile);
		my $rootNode = $binaryCDFFileMap{$afile}{root};

		# Get the total list of files present in the cdf file.
		my @binaryList = &genericparser::getChildElements($rootNode);

		# Hash Reference to the hash map binaryInfo
		my $binaryInfoHashRef;

		foreach my $binaryNode (@binaryList)
		{
			my $fileId = &genericparser::getAttrValue($binaryNode, "id");
			$binaryInfoHashRef = \%{$binaryInfo{$fileId}};
			&setBinaryInfo($binaryInfoHashRef, $binaryNode);
		}
	}

}

#Sets the information of the CDF file to a hash map
sub setBinaryInfo
{
	my ($aBinaryInfoRef, $aBinaryNode) = @_;

	# Set the File attributes
	$aBinaryInfoRef->{"id"}		  = &genericparser::getAttrValue($aBinaryNode, "id");
	$aBinaryInfoRef->{"customisable"} = &genericparser::getAttrValue($aBinaryNode, "customisable");
	$aBinaryInfoRef->{"addressable"}  = &genericparser::getAttrValue($aBinaryNode, "addressable");
	$aBinaryInfoRef->{"compress"}	  = &genericparser::getAttrValue($aBinaryNode, "compress");
	$aBinaryInfoRef->{"type"}	  = &genericparser::getAttrValue($aBinaryNode, "type");
  	$aBinaryInfoRef->{"plugin_name"}  = &genericparser::getAttrValue($aBinaryNode, "plugin_name");
  
  	# Check for the plugin, setting the plugin type as ECOM_PLUGIN
   
  	if (defined $aBinaryInfoRef->{"plugin_name"})
  	{
  		$aBinaryInfoRef->{"IsFoundInCDF"} = 1;
  		$aBinaryInfoRef->{"source"} = "ABI_DIR\\BUILD_DIR\\$aBinaryInfoRef->{id}";
  		$aBinaryInfoRef->{"plugin_name"} =~ s/$aBinaryInfoRef->{plugin_name}/ECOM/;
  	}
  
  	else {

		# Get all the nodes of element 'file'
		my @children = &genericparser::getChildElements($aBinaryNode);

		foreach my $childNode (@children)
		{
			$aBinaryInfoRef->{"IsFoundInCDF"} = 1;

			if (&genericparser::getElementName($childNode) eq "source")
			{
				$aBinaryInfoRef->{"source"} = &genericparser::getElementValue($childNode);
			}

			if (&genericparser::getElementName($childNode) eq "destination")
			{
				$aBinaryInfoRef->{"destination"} = &genericparser::getElementValue($childNode);
			}

			if (&genericparser::getElementName($childNode) eq "features")
			{
				# The children nodes will specify the list of features
				my @aFeatureNodes = &genericparser::getChildElements($childNode);
				foreach my $aFeatureChildNode (@aFeatureNodes)
				{
					# A list of features can be listed out either for supported case or for the prevented case.
					if (&genericparser::getElementName($aFeatureChildNode) eq "supports")
					{
						my @aSupportedFeatureNodes = &genericparser::getChildElements($aFeatureChildNode);
						foreach my $aSuppChildNode (@aSupportedFeatureNodes)
						{
							my %feat = ();
							my $featureName = &genericparser::getAttrValue($aSuppChildNode, "name");
							my $featureUID = &genericparser::getAttrValue($aSuppChildNode, "uid");
							if (defined ($featureName) and ($featureName ne ""))
							{
								$feat{name} = $featureName ;
								$feat{uid} = undef;
							}
							elsif(defined ($featureUID) and ($featureUID ne ""))
							{
								if(&featureparser::ValidateUIDValue($featureUID))
								{
									$featureUID = &featureparser::ConvertHexToDecimal($featureUID);
									$feat{uid} = $featureUID;
									$feat{name} = undef;
								}
								else
								{
									print "The uid value $featureUID specified for the Include feature list for the Binary, $aBinaryInfoRef->{id}, is not a valid number\n";
								}
							}
							else
							{
								print ("Warning: Feature $featureName has both name and Uid mentioned\n") if ($warning_level < 2);
								next;
							}

							$feat{include} = 1;
							push @includeFeatureList, \%feat;
					 
						}
					}
					if (&genericparser::getElementName($aFeatureChildNode) eq "prevents")
					{
						my @aPreventedFeatureNodes = &genericparser::getChildElements($aFeatureChildNode);
						foreach my $aPreventedChildNode (@aPreventedFeatureNodes)
						{
							my %feat = ();
							my $featureName = &genericparser::getAttrValue($aPreventedChildNode, "name");
							my $featureUID = &genericparser::getAttrValue($aPreventedChildNode, "uid");
							if (defined ($featureName) and ($featureName ne ""))
							{
								$feat{name} = $featureName ;
								$feat{uid} = undef;
							}
							elsif(defined ($featureUID) and ($featureUID ne ""))
							{
								if(&featureparser::ValidateUIDValue($featureUID))
								{
									$featureUID = &featureparser::ConvertHexToDecimal($featureUID);
									$feat{uid} = $featureUID;
									$feat{name} = undef;
								}
								else
								{
									print "The uid value $featureUID specified for the Exclude feature list for the Binary, $aBinaryInfoRef->{id}, is not a valid number\n";
								}
							}
							else
							{
								print "Warning: Feature $featureName has both name and Uid mentioned\n" if ($warning_level < 2);
								next;
							}

							$feat{exclude} = 1;
							push @excludeFeatureList, \%feat;
					 
						}
						push @{$aBinaryInfoRef->{"prevents"}}, (&genericparser::getElementValue($aFeatureChildNode));
					}
				}
			}

			if (&genericparser::getElementName($childNode) eq "dynamicdependencies")
			{
				# The children nodes will contain the file name.
				my @aDynDependNodes = &genericparser::getChildElements($childNode);
				
				foreach my $aDynDependChildNode (@aDynDependNodes)
				{
					# There can be a list of binaries for dynamic dependencies
					if (&genericparser::getElementName($aDynDependChildNode) eq "depend")
					{
						push @{$aBinaryInfoRef->{"depend"}}, (&genericparser::getElementValue($aDynDependChildNode));
					}
				}
			}

			if (&genericparser::getElementName($childNode) eq "localisation")
			{
				# The children nodes will contain the language code
				my @aLocalisationNodes = &genericparser::getChildElements($childNode);
				
				foreach my $aLocalisationChildNode (@aLocalisationNodes)
				{
					# There can be a list of binaries for dynamic dependencies
					if (&genericparser::getElementName($aLocalisationChildNode) eq "default")
					{
						$aBinaryInfoRef->{"default"} = &genericparser::getElementValue($aLocalisationChildNode);
					}
					if (&genericparser::getElementName($aLocalisationChildNode) eq "language")
					{
						push @{$aBinaryInfoRef->{"language"}}, (&genericparser::getElementValue($aLocalisationChildNode));
					}
				}
			}

			if (&genericparser::getElementName($childNode) eq "options")
			{
				# The children nodes will contain the option details
				my @aOptionNodes = &genericparser::getChildElements($childNode);
				foreach my $aOptionChildNode (@aOptionNodes)
				{
					if (&genericparser::getElementName($aOptionChildNode) eq "multilinguify")
					{
						$aBinaryInfoRef->{"multilinguify"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "stack")
					{
						$aBinaryInfoRef->{"stack"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "heapmin")
					{
						$aBinaryInfoRef->{"heapmin"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "heapmax")
					{
						$aBinaryInfoRef->{"heapmax"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "fixed")
					{
						$aBinaryInfoRef->{"fixed"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "priority")
					{
						$aBinaryInfoRef->{"priority"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "uid1")
					{
						$aBinaryInfoRef->{"uid1"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "uid2")
					{
						$aBinaryInfoRef->{"uid2"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "uid3")
					{
						$aBinaryInfoRef->{"uid3"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "dll")
					{
						$aBinaryInfoRef->{"dll"} = &genericparser::getElementValue($aOptionChildNode);
					}
					if (&genericparser::getElementName($aOptionChildNode) eq "dlldatatop")
					{
						$aBinaryInfoRef->{"dlldatatop"} = &genericparser::getElementValue($aOptionChildNode);
					}
				}
			}
		}
	}
}

# To get the complete list of information for a given binary
# Input Parameter : Binary
# Returns the detailed information for each binary
sub GetBinaryInfo
{
	my $aBinary = shift;
	my $aBinaryInfoHash = \%{$binaryInfo{$aBinary}};
	if ($aBinaryInfoHash->{IsFoundInCDF})
	{
		return $aBinaryInfoHash;
	}
	return undef;
}

# To get the complete list of dynamic dependencies for a given binary
# Input Parameter : Binary
# Returns the complete list of dynamic dependencies
sub GetDynamicDependencies
{
	my $aBinary = shift;

	my $bin = \%{$binaryInfo{$aBinary}};

	return \@{$bin->{"depend"}};
}

#Returns the included feature list
sub GetIncludedFeatureList
{
	return \@includeFeatureList;
}

#Returns the excluded feature list
sub GetExcludedFeatureList
{
	return \@excludeFeatureList;
}

1;