#

# 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: 

#

use strict;

use warnings;

use File::Spec::Functions;

use Getopt::Long;

use Pod::Usage;

# Version of the script - just use the date

# New getopt::long provides this - but old version doesn't?

sub version

  {

  print sprintf("$0: $main::VERSION\n$^X: %vd\nos: $^O", $^V);

  exit;

  }

# Get arguments

my ( $help, $version, $verbose, $debug, $epocroot, $l10n );

GetOptions( "help" => \$help, "version|ver" => \$version,

      "verbose|v" => \$verbose,  "debug" => \$debug,

      "epocroot|e=s" => \$epocroot, "localization|l=s" => \$l10n )

  or pod2usage('Invalid parameters');

# Handle help and version

pod2usage({ verbose => 1, exitval => 0}) if $help;

version() if $version;

# Interpret arguments

$verbose = 1 if $debug;

$verbose = $verbose ? '-v' : '';

$epocroot = $ENV{EPOCROOT} if !$epocroot;

# Interpret localization l10n argument

# There are two modes.  In one mode you specify the location of a

# lproj.xml file and the code computes l10n files for all languages so

# that runtime locale selection should work.  In the other mode you

# specify a language code (example, fr for French) and the code

# computes l10n just for that language.

$l10n = '' if !$l10n;

my $lproj = '';

if ($l10n =~ /lproj\.xml$/i)

  {

  $lproj = $l10n;

  $l10n = '';

  }

my ($configini, @unnecessary) = @ARGV;

if ($configini)

  {

  # There shouldn't be any need for any other arguments

  pod2usage('Unnecessary arguments supplied.') if @unnecessary;

  # Now do the installation

  my $installer = WidgetInstaller->new('verbose' => $verbose, 'debug' => $debug, 'epocroot' => $epocroot, 'lproj' => $lproj, 'l10n' => $l10n);

  $installer->installConfig($configini);

  }

else

  {

  pod2usage('Missing config.ini argument.');

  }

# ***

# Package for installing Widgets

#

package WidgetInstaller;

use File::Spec::Functions;

use File::Path;

use File::Basename;

use Unicode::String qw(utf8 utf16);

use File::Temp qw/tempdir/;

use File::Copy;

use XML::Parser;

use Data::Dumper;

use XML::Simple;

# CONSTANTS

use constant ICON_SIZES => "88,32,24";      # Size of icons to generate in the MBM file

#use constant INTERNAL_UID_LOWER => 0x2000DAD2; # Lower UID bound for midlets installed to internal drives and rom

#use constant EXTERNAL_UID_LOWER => 0x2000DCC6; # Lower UID bound for midlets installed to removable cards

use constant INTERNAL_UID_LOWER_WRT => 0x2000DAD2;  # Lower UID bound for WRT widgets installed to internal drives and rom

use constant INTERNAL_UID_LOWER_CWRT => 0x2000DBCC; # Lower UID bound for CWRT widgets installed to internal drives and rom

use constant EXTERNAL_UID_LOWER_WRT => 0x2000DCC6;  # Lower UID bound for WRT widgets installed to removable cards

use constant EXTERNAL_UID_LOWER_CWRT => 0x2000DDC0; # Lower UID bound for CWRT widgets installed to removable cards

use constant WIDGET_UI_UID => 0x10282822;   # UID of the widget app

use constant CWRT_WIDGET_UI_UID => 0x200267C0;    # UID of the cwrt widget app

use constant SWIDGET_UI_UID => 0x102829A0;	# UID of the securewidget app

use constant CWRT_WIDGET_UI_NON_NOKIA_UID => 0x200267D6;    # UID of the cwrt widget app

use constant JIL_NS => 'http://www.jil.org/ns/widgets1.2';

# Folder paths

use constant DESTINATION => 'private/10003a3f/import/apps/NonNative/Resource';

use constant ROM_DEST => 'epoc32/release/winscw/udeb/Z/';

use constant DRIVE_DEST => 'epoc32/winscw/%s';

use constant WIDGET_REGISTRY => 'private/10282f06/WidgetEntryStore.xml';

use constant CWRT_WIDGET_REGISTRY => 'private/10282f06/CWRTWidgetEntryStore.xml';

use constant CWRT_WEBAPP_REGISTRY => 'private/200267D9/webapp_registry.db';

use constant CWRT_ACCESS_POLICY_PATH => 'browser_access_policy.xml';

use constant WIDGET_NAME => 'en-gb/widget/name';

use constant WIDGET_PROCESSUID => 'processUid';

use constant WIDGET_ID => 'widget/id';

use constant WIDGET_VERSION => 'widget/version';

use constant WIDGET_CONTENT => 'widget/content';

use constant WIDGET_FEATURE => 'widget/feature/';

use constant WIDGET_FEATURE_PARAM => '/param/';

use constant WIDGET_ACCESS => 'widget/access/';

use constant WIDGET_HEIGHT => 'widget/height';

use constant WIDGET_WIDTH => 'widget/width';

use constant WIDGET_NOKIA_SHAREDLIB => 'widget/NOKIA:sharedlibrary';

use constant WIDGET_NOKIA_SHAREDLIB_FOLDER => 'widget/NOKIA:sharedlibrary/NOKIA:folder';

use constant WIDGET_NOKIA_SHAREDLIB_WIDGET => 'widget/NOKIA:sharedlibrary/NOKIA:widget';

use constant WIDGET_NOKIA_SHAREDLIB_ICON => 'widget/NOKIA:sharedlibrary/NOKIA:icon';

use constant KEY_VALUE_SEPERATOR => ',';

use constant KEY_VALUE_PAIR_SEPERATOR => ';';

use constant KEY_ATTR_SEPERATOR => ':';

our $w3c_widget = 0 ;

our $hashval;

our $non_nokia_widget = 0;

our (@staticUidWrtIntList,@staticUidCwrtIntList,@staticUidWrtExtList,@staticUidCwrtExtList) = ({},{},{},{});

our $isSecureWidget = 0;

# Create a new object

sub new

  {

  my $invocant = shift;

  my $self = bless({}, ref $invocant || $invocant);

  my %args = @_;

  $self->{'args'} = \%args;

  $self->{'args'}->{'verbose'} = $self->{'args'}->{'verbose'} ? '-v' : '';

  $self->{'installedFiles'} = ();

  $self->{'freeuidwrtint'} = INTERNAL_UID_LOWER_WRT;

  $self->{'freeuidwrtext'} = EXTERNAL_UID_LOWER_WRT;

  $self->{'freeuidcwrtint'} = INTERNAL_UID_LOWER_CWRT;

  $self->{'freeuidcwrtext'} = EXTERNAL_UID_LOWER_CWRT;

  $self->{'langmapping'} = $self->getLangMapping($self->{'args'}->{'lproj'}) unless $self->{'args'}->{'l10n'};

  #Check if localisation argument is land number ID; If true, get the lang Name using langmapping file - Widget_lproj.xml 

  if ($l10n =~ /\d+$/)

  {

    print "\nLANG ID given as localisation argument :: $l10n \n";

    $self->{'langmapping'} = $self->getLangMapping();

    if($self->{'langmapping'})

    {

      # Iterate through all the languages we know about

      for(my $i = 0; $i < scalar(@{ $self->{'langmapping'}->{LangID} }); $i++)

      {

        my ( $langid, $langname ) = ( $self->{'langmapping'}->{LangID}->[$i], $self->{'langmapping'}->{LangDir}->[$i] );

        if($l10n == $langid)

        {

          print "Setting argument to LangName - $langname \n";

          $self->{'args'}->{'l10n'} = lc($langname);

          last;

        }

      }

    }

  }

  return $self;

  }

# Gets the language mapping from the Widget_lproj.xml file

sub getLangMapping

  {

  my ( $self, $lproj ) = @_;

  # Get the LPROJ file which specifies lang id mappings

  if (!$lproj)

    {

    (my $EPOCROOT = $ENV{EPOCROOT}) =~ s/[\/\\]+$//;

    $lproj = WidgetInstaller::fixFilename("${epocroot}epoc32/winscw/c/private/10282f06/Widget_lproj.xml");

    $lproj = WidgetInstaller::fixFilename("$EPOCROOT/epoc32/winscw/c/private/10282f06/Widget_lproj.xml") if !-e $lproj;

    $lproj = WidgetInstaller::fixFilename("${epocroot}epoc32/data/Z/private/10282f06/Widget_lproj.xml") if !-e $lproj;

    $lproj = WidgetInstaller::fixFilename("$EPOCROOT/epoc32/data/Z/private/10282f06/Widget_lproj.xml") if !-e $lproj;

    $lproj = WidgetInstaller::fixFilename("${epocroot}S60/mw/web/WebEngine/WidgetRegistry/Data/Widget_lproj.xml") if !-e $lproj;

    $lproj = WidgetInstaller::fixFilename("$EPOCROOT/S60/mw/web/WebEngine/WidgetRegistry/Data/Widget_lproj.xml") if !-e $lproj;

    $lproj = WidgetInstaller::findCmd('Widget_lproj.xml') if !-e $lproj;

    $lproj = WidgetInstaller::findCmd('internal/Widget_lproj.xml') if !-e $lproj;

    undef $lproj if !-e $lproj;

    # Display a warning if localisation can't be performed

    warn "WARNING: Can't find Widget_lproj.xml - localisation is disabled.\n" if !$lproj;

    }

  # Load the mapping file

  if ($lproj)

    {

    die "Can't find $lproj file." if !-e $lproj;

    print "Localisation support enabled using config: $lproj\n" if $verbose;

    my $mapping = XMLin($lproj);

    print "Found ", scalar(@{ $mapping->{'LangID'} }), " language mappings.\n" if $verbose;

    return $mapping;

    }

  }

# Install Widgets listed in config file

# Format is as follows where "drive-z" specifies widgets for drive z: etc...

# Comments are okay - they start with a # character

# If the file doesn't exist as given then EPOCROOT is prepended to the filename to try and find it

#

# You can specify whether a widget is intended for the homescreen by adding the text [HomeScreen] after the filename

# This will set the BlanketPermissionGranted attribute in the registry.

# Widgets intended for the homescreen must have the MiniViewEnabled attribute set in its PLIST file otherwise an error is generated.

#

# You can specify commands to run before exit after a [run-commands] or [homescreen-processor] 

#

# [drive-z]

# \path\widget1.wgz

# widget2.wdgt.zip [HomeScreen]

#

# [drive-e]

# widget3.wgz

#

# [run-commands]

# dostuff.pl

#

sub installConfig

  {

  my ( $self, $file ) = @_;

  $self->{'installedFiles'} = ();

  my ( %installData, $sectionName );

  open CONFIG, $file or die "Failed to open config file $file: $!";

  # Loop for gathering STATIC UIDs allocated for widgets in config INI file

  while(my $line = <CONFIG>)

  {

    # Ignore comments

    $line =~ s/\#.*$//;

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

      {

      $sectionName = lc $1;

      next;

      }

    # Process sections after this point

    next if !$sectionName;

    chomp $line;

    # Have we found a list of widgets?

    if ($sectionName =~ /^drive-([a-z])/)

    {

      my $drive = uc($1);

      #Assuming Static UID given in ini are within int/ext/wgt/wgz specified ranges

      # Add Static UID to the respective list

      if ($line =~ /^(.+?\.(?:wdgt\.zip|wgz|wgt))\s*(\[HomeScreen\])?\s*(0x[a-fA-F0-9]{8})?\s*(\[Operator\])?\s*$/i)

      {

        if ($3)

        {

          my $uid = hex($3);

          if ($drive =~ /^[zcZC]/)

          {

            if(($uid >= INTERNAL_UID_LOWER_WRT) && ($uid < INTERNAL_UID_LOWER_CWRT))

            {

              push(@staticUidWrtIntList,$uid) ;

            }

            else

            {

              push(@staticUidCwrtIntList,$uid);

            }

          }

          else

          {

            if(($uid >= EXTERNAL_UID_LOWER_WRT) && ($uid < EXTERNAL_UID_LOWER_CWRT))

            {

              push(@staticUidWrtExtList,$uid) ;

            }

            else

            {

              push(@staticUidCwrtExtList,$uid) ;

            }

          }

        }

      }

    }

  }

  close CONFIG;

  @staticUidWrtIntList = sort(@staticUidWrtIntList);

  print "SORTED WRT INTERNAL STATIC UID  @staticUidWrtIntList \n";

  @staticUidCwrtIntList = sort(@staticUidCwrtIntList);

  print "SORTED CWRT INTERNAL STATIC UID  @staticUidCwrtIntList \n";

  @staticUidWrtExtList = sort(@staticUidWrtExtList);

  print "SORTED WRT EXTERNAL STATIC UID @staticUidWrtExtList \n";

  @staticUidCwrtExtList = sort(@staticUidCwrtExtList);

  print "SORTED CWRT EXTERNAL STATIC UID @staticUidCwrtExtList \n";

  open CONFIG, $file or die "Failed to open config file $file: $!";

  # Main loop which reads the config INI line by line and installs widgets[wgz/wgt] in respective drives

  while(my $line = <CONFIG>)

    {

    # Ignore comments

    $line =~ s/\#.*$//;

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

      {

      $sectionName = lc $1;

      # Remember destination if any specified

      if ($sectionName =~ /^drive-([a-z])=(.+)$/)

        {

        $self->{'destination'}->{uc($1)} = $2;

        }

      next;

      }

    # Process sections after this point

    next if !$sectionName;

    chomp $line;

    # Have we found a list of widgets?

    if ($sectionName =~ /^drive-([a-z])/)

      {

      my $drive = uc($1);

      # Add to the list of Widget files

      if ($line =~ /^(.+?\.(?:wdgt\.zip|wgz|wgt))\s*(\[HomeScreen\])?\s*(0x[a-fA-F0-9]{8})?\s*(\[Operator\])?\s*$/i)

        {

        my $widget = $1;

        $widget = fixFilename(catfile($self->{'args'}->{'epocroot'}, $1)) if !-e $widget;

        die "Can't find widget $widget" if !-e $widget;

        $self->{'homescreen'}{lc $widget} = 1 if $2; # Intended for the homescreen?

        $self->{'staticUID'}{lc $widget} = hex($3) if $3;

        $self->{'secure'}{lc $widget} = 0;

        $self->{'operator'}{lc $widget} = 1 if $4;

        print "Widget for drive $drive: $widget\n" if $self->{'args'}->{'verbose'};

        push @{ $installData{"$drive:"} }, $widget;

        }

      elsif ($line =~ /^(.+?\.(?:wdgt\.zip|wgz))\s*(\[Secure\])?\s*(0x[a-fA-F0-9]{8})?\s*$/i)

        {

          my $widget = $1;

          $widget = fixFilename(catfile($self->{'args'}->{'epocroot'}, $1)) if !-e $widget;

          die "Can't find widget $widget" if !-e $widget;

          $self->{'secure'}{lc $widget} = 1 if $2; # Intended for a secure widget handling?

          $self->{'staticUID'}{lc $widget} = hex($3) if $3;

          print "Widget for drive $drive: $widget\n" if $self->{'args'}->{'verbose'};

          push @{ $installData{"$drive:"} }, $widget;

        }

      else

      	{

      		my $widget = $1;

      		$self->{'secure'}{lc $widget} = 0;

        }	

      }

    # Retrieve the command to execute before exit

    elsif ($sectionName =~ /^(run-commands|homescreen-processor)$/i && $line)

      {

      push @{ $self->{'exitcmds'} }, $line;

      }

    }

  close CONFIG;

  # Now intall the widgets for each drive specified in the config file

  foreach my $drive ( keys %installData )

    {

    $self->installFiles($drive, $installData{$drive} );

    $self->makeIBY($drive);

    $self->makeIBY($drive, 'localised') unless $self->{'args'}->{'l10n'};

    }

  # Exit commands at the end of the process

  if ($self->{'exitcmds'})

    {

    foreach my $cmd ( @{ $self->{'exitcmds'} } )

      {

      print "Executing: $cmd\n" if $self->{'args'}->{'verbose'};

      warn "WARNING: error running $cmd" if system($cmd) != 0;

      }

    }

  }

# ***

# Installs files to a drive

#

sub installFiles

  {

  my ( $self, $drive, $fileList ) = @_;

  my $startsrc ;

    my $iconsrc ;

   $isSharedLibrary = 0;

   $isSharedWidget = 0;

   $isSharedIcon = 0;

   $sharedFolderName ='';

   $isSecureWidget = 0;

  print "Installing files for drive $drive\n" if $self->{'args'}->{'verbose'};

  # Unregister any existing widgets as otherwise when the registry is rewritten their icons will appear in the emulator but they won't work

  $self->unregisterWidgets($drive);

  print "\n     INSTALLING FILES FOR DRIVE $drive       \n";

  # Process each widget in turn

  my ( @installedProps );

  my ( @installedCWRTProps );

  foreach my $filename ( @$fileList )

    {

    # Check the file exists

    die "Can't find $filename" if !-e $filename;

    # Create a temporary folder

    print "\nInstalling $filename\n";

    my $tempdir = tempdir ( DIR => '.', CLEANUP => !$self->{args}->{'debug'});

    # Prefer to use 7zip rather than unzip because it's better behaved wrt Unicode

    if (findCmd('7z.exe'))

      {

      $self->un7zipWidget($filename, $tempdir);

      }

    else

      {

      $self->unzipWidget($filename, $tempdir);

      }

        my $widgetdata ;

        $isSharedLibrary = 0;

        $isSharedWidget = 0;

        $isSharedIcon = 0;

        $sharedFolderName ='';

    my ( $root, $extracted, $size ) = $self->getFiles($tempdir);

    die "No files extracted from $filename" if !@$extracted;

    if ($self->{'operator'}{lc $filename})

      print "\nNON NOKIA WGT \n";

    }

    else

    {

      print "\nNOKIA WGT \n";

    }

    if (($filename =~ /.wgz/ )&& (my $plist = catfile($tempdir, $root, 'Info.plist')))

      {

          print ("S60 widget \n");

          $w3c_widget = 0;

          # Parse the XML file into a hash

              $widgetdata = parsePList($plist);

      }

    elsif (($filename =~ /.wgt/ ) && ( my $confxml = catfile($tempdir, $root, 'config.xml')))

      {

        print ("W3C widget \n");

          # Parse the XML file into a hash

            $widgetdata = parseConfXml($confxml,$self->{'args'}->{'l10n'});

            $w3c_widget = 1;

      }

    else

      {

      die "Can't find $root/Info.plist , $root/config.xml file";

      }       

	  if ($self->{'secure'}{lc $filename}){

		$isSecureWidget = 1;

	  } else {

	  	$isSecureWidget = 0;

	  }

    if( $w3c_widget )

    { 

      if( $widgetdata->{'MainHTML'} )

        {

        $startsrc = $widgetdata->{'MainHTML'};

        }

      else

        {

        $startsrc = 'index.html';

        }

      if( $widgetdata->{'IconPath'} )

        {

        $iconsrc = $widgetdata->{'IconPath'};

        }

      else

        {

        $iconsrc = 'icon.png';   

        }

  		if($non_nokia_widget)

  		{

  			$widgetdata->{'ProcessUid'} = CWRT_WIDGET_UI_NON_NOKIA_UID;

  		}

  		else

  		{

      		$widgetdata->{'ProcessUid'} = CWRT_WIDGET_UI_UID;

      	}

      $widgetdata->{'MimeType'} = "application/widget";

    }         

    print "Identifier: $widgetdata->{'BundleIdentifier'}\n" if $self->{args}->{'verbose'};

    # Set widget package properties

    $widgetdata->{'FileName'} = $filename;

    $widgetdata->{'FileSize'} = $size;