#

# 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 "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 Feature manager XML file.

package featuremanager; # Derived class for the feature manager xml parser

BEGIN {

	@ISA = qw(featureparser); # Derived from featuerParser

	require featureparser;

};

use constant STRICTCASE=>1; # To suppress the case conversion in genericparser routine

# Parse the featuredatabase XML file and generate the maps and counts

#

#featureset:

# {namespace}<namespace> - optional

# {ibyname}<ibyname> - optional

# {hfilename}<hfilename> - optional

# {hfileheader}<fileheader> - optional

# {interfacestatus}<interfacestatus> -optional

# {interfacevisibility}<interfacevisibility> - optional

# {feature_list}<nameuidmap>

# {feature} {<uid1>}{statusflags}<statusflag>

#					{name}<name>

#					{userdata}<userdata> - optional

#					{includemacro}<macro>

#					{excludemacro}<macro>

#					{infeaturesetiby}<yes/no> - optional

#					{comment}<comment> - optional

#			{<uid2>}{statusflags}<statusflag>

#					{name}<name>

#					{userdata}<userdata> - optional

#					{includemacro}<macro>

#					{excludemacro}<macro>

#					{infeaturesetiby}<yes/no> - optional

#					{comment}<comment>

#

#

# Class constructor

#

sub new

{

	my $class = shift;

	my $object = $class->SUPER::new();

	# Class members

	$object->{_OBJNAME} = "FeatureManager"; # Name of the object

	$object->{_FEAT_SET_LIST} = [];  # Array of <featureset> hash maps

	$object->{_FEAT_LIST} = {};      # Hash map of all feature name with uid

	$object->{_ALIAS_FEAT_LIST} = {}; # Hash map of all alias feature name with uid

	return $object;

}

#

# Private methods

#

# Private method to Get/Set the _FEAT_SET_LIST member value of this class

# @param : reference to the array of <featureset> hash maps (optional for GET)

#

my $featuresetList = sub 

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"featuresetList"));

	if (@_) 

	{ 

		$object->{_FEAT_SET_LIST} = shift; 

	}

	return $object->{_FEAT_SET_LIST};

};

# Private method to Get/Set the _FEAT_LIST member value of this class

# @param : reference to the fash map of feature name with uid (optional for GET)

#

my $featureList = sub 

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"featureList"));

	if (@_) 

	{ 

		$object->{_FEAT_LIST} = shift; 

	}

	return $object->{_FEAT_LIST};

};

# Private method ot Get/Set the _ALIAS_FEAT_LIST member value of this class

# @param: reference to the hash map of alias feature name with uid

my $aliasfeatureList = sub

{

	my $object = shift;

	return 0 if(!&featureparser::ISREF($object, "aliasfeatureList"));

	if(@_)

	{

		$object->{_ALIAS_FEAT_LIST} = shift;

	}

	return $object->{_ALIAS_FEAT_LIST};

};

# Read the attributes of <featureset> element

# @param : reference to the featureset

# @param : reference to the attributemap

#

my $fillFeatureSetAttributes = sub 

{

	my  $node = shift;

	my  $map = shift;

	$map->{ibyname} = &featureparser::getattrValue($node, "ibyname", STRICTCASE);

	$map->{hfilename} = &featureparser::getattrValue($node, "hfilename", STRICTCASE);

	$map->{namespace} = &featureparser::getattrValue($node, "namespace", STRICTCASE);

};

# Read the attributes of <hfileheader> element

# @param : reference to the featureset

# @param : reference to the attributemap

#

my $fillFileHeaderAttributes = sub 

{

	my $node = shift;

	my $map = shift;

	my @attribSet =  &featureparser::getnodefromTree($node, "hfileheader");

	foreach my $att_node (@attribSet) 

	{

		$map->{interfacestatus} = &featureparser::getattrValue($att_node, "interfacestatus",STRICTCASE);

		$map->{interfacevisibility} = &featureparser::getattrValue($att_node, "interfacevisibility",STRICTCASE);

		$map->{hfileheader} = &featureparser::getelementValue($att_node,STRICTCASE);

	}

};

# Read the attributes of <feature> element

# @param : reference to the featureset

# @param : reference to the attributemap

#

my $fillFeatureAttributes = sub 

{

	my $node = shift; my $map = shift;

	my @attribSet =  &featureparser::getnodefromTree($node, "feature");

	my %nameUidMap = ();

	foreach my $att_node (@attribSet)

	{

		my ($uid_value, $feat_name, $attval);

		my (@macroSet, @commentSet);

		my %featureHash = ();

		#Read the feature name and its other attributes

		$feat_name = &featureparser::getattrValue($att_node, "name",STRICTCASE);

		# Validate Name

		if(!$feat_name) {

			&featureparser::ERROR("Feature name attribute is empty");

			return 0;

		}

		if(exists $nameUidMap{lc($feat_name)}) {

			&featureparser::ERROR("Feature entry \"".$feat_name."\" already exists");

			return 0;

		}

		#Read the uid value

		$uid_value = &featureparser::getattrValue($att_node, "uid");

		if(!&featureparser::IsValidNum($uid_value)) {

			&featureparser::ERROR("Valid hexadecimal or decimal value expected in UID entry for \"$feat_name\"");

			return 0;

		}

		$uid_value = &featureparser::ConvertHexToDecimal($uid_value);

		if((defined $map->{feature}) && (exists $map->{feature}{$uid_value})) {

			&featureparser::ERROR("UID entry for \"".$feat_name."\" already exists");

			return 0;

		}

		$attval = &featureparser::getattrValue($att_node, "statusflags");

		if(!&featureparser::IsValidNum($attval)) {

			&featureparser::ERROR("Valid hexadecimal or decimal value expected in STATUS_FLAGS entry for \"$feat_name\"");

			return 0;

		}

		$featureHash{statusflags} = $attval;

		$attval = &featureparser::getattrValue($att_node, "userdata");

		if(defined $attval) {

			if(!&featureparser::IsValidNum($attval)) {

				&featureparser::ERROR("Valid hexadecimal or decimal value expected in USER_DATA entry for \"$feat_name\"");

				return 0;

			}

		}

		$featureHash{name} = $feat_name;

		$featureHash{userdata} = $attval;

		#Read the attributes of <hrhmacro> element

		@macroSet = &featureparser::getnodefromTree($att_node, "hrhmacro");

		foreach my $nodeMac (@macroSet) {

			$featureHash{includemacro} = &featureparser::getattrValue($nodeMac,"include",STRICTCASE);

			$featureHash{excludemacro} = &featureparser::getattrValue($nodeMac,"exclude",STRICTCASE);

			#Read the attribute infeaturesetiby

			$attval = &featureparser::getattrValue($nodeMac,"infeaturesetiby");

			if(($attval eq undef) or (lc($attval) eq "yes")) {

				$featureHash{infeaturesetiby} = 1;

			}

			elsif(lc($attval) eq "no") {

				$featureHash{infeaturesetiby} = 0;

			}

			else {

				&featureparser::ERROR("(yes|no) value expected in infeaturesetiby attribute for \"$feat_name\"");

				return 0;

			}

		}

		#Read the <comment> element value

		@commentSet = &featureparser::getnodefromTree($att_node, "comment");

		foreach my $nodeCmt (@commentSet) {

			$featureHash{comment} =  &featureparser::getelementValue($nodeCmt,STRICTCASE);

		}

		#Add an entry to name->uid map for this feature

		$nameUidMap{lc($feat_name)} = $uid_value;

		#Add an entry to the global hash map with all the attributes of this feature

		$map->{feature}{$uid_value} = \%featureHash;

	}

	$map->{feature_list} = \%nameUidMap;

	return 1;

};

my $fillAliasAttributes = sub

{

	my $node = shift;

	my $map = shift;

	my %aliasnameUidMap = ();

	my $featureList = $map->{feature_list};

	my @attribSet = &featureparser::getnodefromTree($node, "featureoverride");

	foreach my $att_node (@attribSet)

	{

		my ($uid_value, $alias_name, $feat_name, $attval);

		my (@macroSet, @commentSet);

		my %featureHash = ();

		#read the alias name 

		$alias_name = &featureparser::getattrValue($att_node, "name", STRICTCASE);

		if(!$alias_name)

		{

			&featureparser::ERROR("Featureoverride name attribute is empty");

			return 0;

		}

		if(exists $featureList->{lc($alias_name)})

		{

			&featureparser::ERROR("Can't override <feature> \"".sprintf("0x%08x", $featureList->{lc($alias_name)})."\" in the same <featureset>");

			return 0;

		}

		if(exists $aliasnameUidMap{lc($alias_name)})

		{

			&featureparser::ERROR("Can't override <featureoverride> \"".sprintf("0x%08x", $aliasnameUidMap{lc($alias_name)})."\" in the same <featureset>");

			return 0;

		}

		$uid_value = &featureparser::getattrValue($att_node, "uid");

		if(!&featureparser::IsValidNum($uid_value))

		{

			&featureparser::ERROR("Valid hexadecimal or decimal value expected in UID entry for \"$alias_name\"");

			return 0;

		}

		$uid_value = &featureparser::ConvertHexToDecimal($uid_value);

		if((defined $map->{alias_feature}) && (exists $map->{alias_feature}{$uid_value}))

		{

			&featureparser::ERROR("Can't override <featureoverride> \"".sprintf("0x%08x", $uid_value)."\" in the same <featureset>");

			return 0;

		}

		if((defined $map->{feature}) && (exists $map->{feature}{$uid_value}))

		{

			&featureparser::ERROR("Can't override <feature> \"".sprintf("0x%08x", $uid_value)."\" in the same <featureset>");

			return 0;

		}

		$attval = &featureparser::getattrValue($att_node, "statusflags");

		if(defined $attval)

		{

			if(!&featureparser::IsValidNum($attval))

			{

				&featureparser::ERROR("Valid hexadecimal or decimal value expected in STATUS_FLAGS entry for \"$alias_name\"");

				return 0;

			}

		}

		$featureHash{statusflags} = $attval;

		$attval = &featureparser::getattrValue($att_node, "userdata");

		if(defined $attval)

		{

			if(!&featureparser::IsValidNum($attval))

			{

				&featureparser::ERROR("Valid hexadecimal or decimal value expected in USER_DATA entry for \"$alias_name\"");

				return 0;

			}

		}

		$featureHash{uid} = $uid_value;

		$featureHash{name} = $alias_name;

		$featureHash{userdata} = $attval;

		#read the attributes of <hrhmacro> element

		@macroSet = &featureparser::getnodefromTree($att_node,"hrhmacro");

		foreach my $nodeMac (@macroSet) 

		{

			$featureHash{includemacro} = &featureparser::getattrValue($nodeMac, "include", STRICTCASE);

			$featureHash{excludemacro} = &featureparser::getattrValue($nodeMac, "exclude", STRICTCASE);

			#read the attribute infeaturesetiby

			$attval = &featureparser::getattrValue($nodeMac, "infeaturesetiby");

			if(($attval eq undef) or (lc($attval) eq "yes"))

			{

				$featureHash{infeaturesetiby} = 1;

			}

			elsif(lc($attval) eq "no")

			{

				$featureHash{infeaturesetiby} = 0;

			}

			else

			{

				&featureparser::ERROR("(yes|no) value expected in infeaturesetiby attribute for \"$feat_name\"");

				return 0;

			}

		}

		#read the <comment> element value

		@commentSet = &featureparser::getnodefromTree($att_node, "comment");

		foreach my $nodeCmt (@commentSet)

		{

			$featureHash{comment} = &featureparser::getelementValue($nodeCmt, STRICTCASE);

		}

		#add an entry to alias->uid map for this feature

		$aliasnameUidMap{lc($alias_name)} = $uid_value;

		#add an entry to the global hash map with all the attributes of this alias feature

		$map->{alias_feature}{$uid_value} = \%featureHash;

	}

	$map->{alias_feature_list} = \%aliasnameUidMap;

	return 1;

};

#

# Public methods

#

sub getAliasFeatureList

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"getAliasFeatureList"));

	my $aliasfeatlist = $object->$aliasfeatureList();

	return $aliasfeatlist;

}

# To get the status flag attribute value of the given feature

# @param : feature name

#

sub getStatusFlag

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"getStausFlag"));

	my $name = shift;

	my $namespace = shift;

	my $uid = $object->getFeatureUID($name, $namespace);

	if($uid)

	{

		my $feature = $object->getFeatureInfo($uid, $namespace);

		return ($feature->{statusflags}) if(exists $feature->{statusflags});

	}

	return undef;

}

# To get the user data attribute value of the given feature

# @param : feature name

#

sub getUserData

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"getUserData"));

	my $name = shift;

	my $namespace = shift;

	my $uid = $object->getFeatureUID($name, $namespace);

	if($uid)

	{

		my $feature = $object->getFeatureInfo($uid, $namespace);

		return ($feature->{userdata}) if(exists $feature->{userdata});

	}

	return undef;

}

# To get the include macro attribute value of the given feature

# @param : feature name

#

sub getIncludeMacro

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"getIncludeMacro"));

	my $name = shift;

	my $uid = $object->getfeatureUID($name);

	if($uid)

	{

		my $feature = $object->getfeatureInfo($uid);

		return $feature->{includemacro};

	}

	return undef;

}

# To get the exclude macro attribute value of the given feature

# @param : feature name

#

sub getExcludeMacro

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"getExcludeMacro"));

	my $name = shift;

	my $uid = $object->getfeatureUID($name);

	if($uid)

	{

		my $feature = $object->getfeatureInfo($uid);

		return $feature->{excludemacro};

	}

	return undef;

}

# Return the feature uid for the given feature name.

# @param : Feature Name

# @param : namespace of the featureset (optional)

#

sub getFeatureUID

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"getFeatureUID"));

	my $feature = shift;

	my $namespace = shift;

	my $featuresetList = $object->$featuresetList;

	$feature = lc($feature);

	if($namespace eq undef)	{

		if(exists $$featuresetList[0]->{feature_list}{$feature}) {

			return $$featuresetList[0]->{feature_list}{$feature};

		}

		if(exists $$featuresetList[0]->{alias_feature_list}{$feature}) {

			return $$featuresetList[0]->{alias_feature_list}{$feature};

		}

	}

	else {

		foreach my $node (@$featuresetList)

		{

			if((lc($node->{namespace}) eq lc($namespace)) && ((exists $node->{feature_list}{$feature})||(exists $node->{alias_feature_list}{$feature}))) {

				return $node->{feature_list}{$feature} if (exists $node->{feature_list}{$feature});

				return $node->{alias_feature_list}{$feature} if (exists $node->{alias_feature_list}{$feature});

			}

		}

	}

	foreach my $node (@$featuresetList) {

		return $node->{feature_list}{$feature} if(exists $node->{feature_list}{$feature});

		return $node->{alias_feature_list}{$feature} if(exists $node->{alias_feature_list}{$feature});

	}

	return undef;

}

# Get the details of feature with given featureuid and other parameters

# This function only consider the feature UID only and that UID should be in decimal

# @param : Feature UID

# @param : namespace of the featureset (optional)

#

sub getFeatureInfo

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"getFeatureInfo"));

	my $uid = shift;

	my $namespace = shift;

	my $featuresetList = $object->$featuresetList;

	if($namespace eq undef)	{

		foreach my $node (@$featuresetList) {

			return $node->{alias_feature}{$uid} if(exists $node->{alias_feature}{$uid});

		}

		if(exists $$featuresetList[0]->{feature}{$uid}) {

			return $$featuresetList[0]->{feature}{$uid};

		}

		if(exists $$featuresetList[0]->{alias_feature}{$uid}) {

			return $$featuresetList[0]->{alias_feature}{$uid};

		}

	}

	else {

		foreach my $node (@$featuresetList)

		{

			if((lc($node->{namespace}) eq lc($namespace)) && ((exists $node->{feature}{$uid})||(exists $node->{alias_feature}{$uid}))) {

				return $node->{feature}{$uid} if (exists $node->{feature}{$uid});

				return $node->{alias_feature}{$uid} if (exists $node->{alias_feature}{$uid});

			}

		}

	}

	foreach my $node (@$featuresetList) {

		return $node->{feature}{$uid} if(exists $node->{feature}{$uid});

	}

	return undef;

}

# Get the Feature set info as a hash

# @param: namespace of the featureset

#

sub getFeaturesetInfo 

{

	my $object = shift; 

	return 0 if(!&featureparser::ISREF($object,"getFeaturesetInfo"));