#

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

#

######################################

# Run with -h to get help

######################################

use strict;

use lib   ".";

use open OUT => ':raw';

use Win32::OLE qw(in with);

use Win32::OLE::Const 'Microsoft Excel';

use Cwd;

use Getopt::Long;

use File::Copy;

use Storable qw(fd_retrieve);

use excel_support;  # Own perl module that contains the reading of memory-sheets

use cenrep_keys;  # Own perl module that contains the reading of memory-sheets

use Data::Dumper;

# this is the bit mask that is put into the metadata in the ini-file, when

# backup is set on.

my $globalBackupValue = 0x01000000;

###########################################################################

###########################################################################

sub printStr

{

    my $to = shift;

    my $str = shift;

    for (my $i = 0; $i < length($str); $i++) 

    {

	printf $to "%s\0", substr($str,$i, 1);

    }

}

###########################################################################

###########################################################################

sub printNewLine

{

    my $to = shift;

    my $fileName = shift;

    print $to "\x0D\x00\x0A\x00";

    return;

}

#      # We need to close the file temporarely so that we can

#      # write a new line into it differently. It seems that

#      # unicode file name writing is somehow wrong in the 

#      # used perl versio (ActivePerl 5.8.4)

#      close $to;

#      # Writing the new line into the end of the line

#      open $to,">>$fileName";

#      binmode OUT;

#      print OUT chr(13);

#      print OUT chr(0);

#      print OUT chr(10);

#      print OUT chr(0);

#      close OUT;

#      # Opening the file again to

#  #    open(OUT,">>:encoding(UTF-16LE)",$fileName) || die "unable to open $fileName";

#      open(OUT,">>$fileName") || die "unable to open $fileName";

#  }

###########################################################################

# Function that gets a dir as parameter and reads the list of excel files from the

# given directory.

#

# Params: a directory name

#

# Return value: a reference to a list of filenames.

###########################################################################

sub getExcelFilesFromDir

{

    my $dir = shift;

    # the given dir should be relative to the dir, where the script is executed.

    if($dir !~ /^[\\\/]/ && $dir !~ /^[A-Za-z]:/)

    {

	$dir =  cwd . "\\$dir"; 

    }

    my @files;

    @files = <$dir\\*.xls >;

    return \@files;

}

###################################################

# Function that reads the file names from the given file.

# THe information is read from Column A and 1st empty row indicates

# end of input.

#

# Params: fileNameRead, refToExcelApp

###################################################

sub getExcelFilesFromFile

{

    my $file = shift;

    my @fileList;

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

    # Open the file

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

    open(IN,$file) || die "Unable to open: $file";

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

    # Read file line by line

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

    while(<IN>)

    {

	my $fileWithPath = $_;

	chomp($fileWithPath);

	if(! -f $fileWithPath)

	{

	    print STDERR "Warning: input file not found: $fileWithPath\n";

	}

	else

	{

	    push(@fileList,$fileWithPath);

	}

    }

    return \@fileList;

}

###################################################

###################################################

sub isRemoved

{

    my $platId = shift;

    my $platRel = shift;

    my $removed = shift;

    # If not defined => not removed

    if(! defined($removed))

    {

	return 0;

    }

    if($removed =~ /$platId\s+([0-9]+\.[0-9]+)/i)

    {

	my $rel = $1;

	if($rel <= $platRel)

	{

	    return 1;

	}

    }

    return 0;    

}

###################################################

# returns the official capa name from internal name.

# this is implemented since the capa names in cenrep keys

# migth not be the same as official names in the ini-file.

###################################################

sub getCapaValue

{

    my $formatNbr      = shift; # not used at the moment.

    my $refToCapaList  = shift;

    #########################

    # official way, caps as strings

    #########################

#      my $retVal = "";

#      my $isFirst = 1;

#      foreach my $capa (@$refToCapaList)

#      {

#  	next if($capa =~ /^\s*$/);

#  	if(!$isFirst)

#  	{

#  	    $retVal .= ",";

#  	}

#  	$retVal .= $capa;

#  	$isFirst = 0;

#      }

    #########################

    # Caps as strings

    #########################

    my $retVal = "";

    my @capaList;

    foreach my $capa (@$refToCapaList)

    {

	next if($capa =~ /^\s*$/);

	if( $capa =~ /ReadUserData/)

	{

	    push(@capaList,"ReadUserData"); 

	}

	elsif($capa =~ /WriteUserData/)

	{

	    push(@capaList,"WriteUserData");

	}

	elsif( $capa =~ /ReadDeviceData/)

	{

	    push(@capaList,"ReadDeviceData");

	}

	elsif($capa =~ /WriteDeviceData/)

	{

	    push(@capaList,"WriteDeviceData");

	}

	elsif($capa =~ /NetworkControl/)

	{

	    push(@capaList,"NetworkControl");

	}

	elsif($capa =~ /NetworkServices/)

	{

	    push(@capaList,"NetworkServices");

	} 

	elsif($capa =~ /Local Services/)

	{

	    push(@capaList,"LocalServices");

	} 

	elsif($capa =~ /Location/)

	{

	    push(@capaList,"Location");

	} 

	elsif($capa =~ /ProtServ/)

	{

	    push(@capaList,"ProtServ");

	} 

	elsif($capa =~ /DRM/)

	{

	    push(@capaList,"DRM");

	} 

	elsif($capa =~ /SwEvent/)

	{

	    push(@capaList,"SwEvent");

	} 

	elsif($capa =~ /PowerMgmt/)

	{

	    push(@capaList,"PowerMgmt");

	} 

	elsif($capa =~ /AllFiles/)

	{

	    push(@capaList,"AllFiles");

	} 

	elsif($capa =~ /DiskAdmin/)

	{

	    push(@capaList,"DiskAdmin");

	} 

	elsif($capa =~ /MultiMediaDD/)

	{

	    push(@capaList,"MultimediaDD");

	} 

	elsif($capa =~ /CommDD/)

	{

	    push(@capaList,"CommDD");

	} 

	elsif($capa =~ /TrustedUI/)

	{

	    push(@capaList,"TrustedUI");

	} 

	elsif($capa =~ /TCB/)

	{

	    push(@capaList,"TCB");

	} 

	elsif($capa =~ /AlwaysPass/  || $capa =~ /None/)

	{

	    push(@capaList,"alwayspass");

	} 

	elsif($capa =~ /UserEnvironment/)

	{

	    push(@capaList,"UserEnvironment");

	} 

	elsif($capa =~ /SurroundingsDD/)

	{

	    push(@capaList,"SurroundingsDD");

	} 

    }

    return join(",",@capaList);

}

###################################################

# 3rd param syntax:

# <release> 

#     => { 

#        "R" => (<capa1ForReading>,<capa2ForReading>)

#        "W" => (<capa1ForWriting>,<capa2ForWriting>)

#        "value" => <value>

#        "rfs"  => <0/1>

#        "backup"  => <0/1>

#         }

#  

###################################################

sub getConfig

{

    my $platId = shift;

    my $platRel = shift;

    my $refToHash = shift;

    my $currRel = "0";

    my $currRef = undef;

    foreach my $plat (sort keys %$refToHash)

    {

	if($plat =~ /$platId\s+([0-9]+\.[0-9]+)/i)

	{

	    my $tentativeRel = $1;

	    if($tentativeRel > $currRel && $tentativeRel <= $platRel)

	    {

		$currRel = $tentativeRel;

		$currRef = $$refToHash{$plat};

	    }

	}

    }

#      if($currRel > 0)

#      {

#  	print $$refToHash{$currRel}, "a\n";

#  	return $$refToHash{$currRel};

#      }

    return $currRef;

}

###########################################################################

# Main function, 

###########################################################################

sub readConfig

{

    my $refToExcelFiles = shift;

    my $refToExcel = shift;

    my %reshHash;

    my $refToWorkSheet;

    # Loop through each found excel sheet. This will open one file after each other

    # and parse information into the hashes defined above.

    foreach my $file ( @{$refToExcelFiles} ) 

    {

	print "   Reading: $file\n";

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

	# Open the file

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

	my $refToWb = openWorkbook( $file,$refToExcel);

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

	# Check, that the template version is the one we support. If not

	# the file is skipped and warning is written to user.

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

#  	if( isSupported($refToWb) == 0)

#  	{

#  	    # "delete" the workbooks, this closes the excel application

#  	    undef $$refToWb;

#  	    undef $refToWb;

#  	    print STDERR "Warning: Unsupported template version in file: $file\n";

#  	    next;

#  	}

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

	# Read the information from the worksheets

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

	for( my $i = 0; $i < $$refToWb->Worksheets->Count; $i++)

	{

	    my $workSheet = $$refToWb->WorkSheets($i + 1);

	    $refToWorkSheet = getWorkSheet( $refToWb,$workSheet->Name);

	    readCentrepKeyInfo( $refToWorkSheet,\%reshHash);

	}

	# "delete" the workbooks, this closes the excel application

	$$refToWb->Close(0);

	undef $$refToWb;

	undef $refToWb;

    }

    return \%reshHash;

}

###########################################################################

###########################################################################

sub getKeyType

{

    my $key = shift;

    return "string" if($key =~ /str/i);

    return "int" if($key =~ /int/i);

    return "real" if($key =~ /real/i);

    return "binary" if($key =~ /bin/i);

    return "unknown_type";

}

###########################################################################

# Prints the Key and key type into the given output.

# The format in which the key is printed is format specific.

###########################################################################

sub printKey

{

    my $to = shift;

    my $formatNbr = shift;

    my $key = shift;

    my $keyType = shift;

    $key =~ s/0x(0*)/0x/g;

    # Add 0 if the key value is "0x" (cases, where the id == 0)

    $key .= "0" if $key =~ /0x\s*$/;

    printStr $to, $key . " " . $keyType . " ";

    return;

}

###########################################################################

# Prints the capabilities into the given output.

# The format in which the capabilities are printed is format specific.

###########################################################################

sub printCapa

{

    my $to = shift;

    my $formatNbr = shift;

    my $refToCapaList = shift;

    my $prefix = shift;

    my $alwaysFail = shift;

    if($formatNbr > 1)

    {

	if($alwaysFail && $formatNbr > 3)

	{

	    printStr \*OUT, " $prefix=alwaysfail";

	}

	elsif(defined($refToCapaList) && scalar(@$refToCapaList) > 0)

	{

	    my $capaStr = getCapaValue($formatNbr,$refToCapaList);

	    printStr \*OUT, " $prefix=$capaStr" if($capaStr);

	}

    }

}

###########################################################################

# Prints the Sid  capabilities into the given output.

# The format in which the capabilities are printed is format specific.

###########################################################################

sub printSidCapa

{

    my $to = shift;

    my $formatNbr = shift;

    my $refToCapaList = shift;

    my $prefix = shift;

    if($formatNbr > 1)

    {

	if(defined($refToCapaList) && scalar(@$refToCapaList) > 0)

	{

	    # Only 1 SID is allowed

	    printStr \*OUT, " $prefix=$$refToCapaList[0]";

	}

    }

}

###########################################################################

# Prints the information about ranges

###########################################################################

sub printPlatSec

{

    my $to = shift;

    my $formatNbr = shift;

    my $refToUidSpecificHash = shift;

    my $refToRangesHash = shift;

    my $fileName = shift;

    my $addDefCaps = shift;

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

    # UID specific (default capabilities)

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

    # we need to know if write / read was specified.

    # if not and addDefCaps is defined => then be add the 

    # default alwayspass to the file

    my $readSpecified = 0;

    my $writeSpecified = 0;

    ###############################

    # RSid-capa writing (format specific)

    ###############################

    my $refToCapaList = $$refToUidSpecificHash{"RSid"};

    printSidCapa($to,$formatNbr,$refToCapaList,"sid_rd");

    $readSpecified += scalar(@$refToCapaList) if defined($refToCapaList);

    ###############################

    # R-capa writing (format specific)

    ###############################

    $refToCapaList = $$refToUidSpecificHash{"R"};

    printCapa($to,$formatNbr,$refToCapaList,"cap_rd",0);

    $readSpecified = scalar(@$refToCapaList) if defined($refToCapaList);

    # Add def caps if no caps were defined

    if($addDefCaps > 0 && $readSpecified < 1)

    {

	printStr \*OUT, " cap_rd=alwayspass";

    }

    ###############################

    # WSid-capa writing (format specific)

    ###############################

    $refToCapaList = $$refToUidSpecificHash{"WSid"};

    printSidCapa($to,$formatNbr,$refToCapaList,"sid_wr");

    $writeSpecified += scalar(@$refToCapaList) if defined($refToCapaList);

    ###############################

    # W-capa writing (format specific)

    ###############################

    $refToCapaList = $$refToUidSpecificHash{"W"};

    printCapa($to,$formatNbr,$refToCapaList,"cap_wr",0);

    $writeSpecified = scalar(@$refToCapaList) if defined($refToCapaList);

    # Add def caps if no caps were defined

    if($addDefCaps > 0 && $writeSpecified < 1)

    {

	printStr \*OUT, " cap_wr=alwayspass";

    }