#

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

#

package AppGen;

use strict;

my $BuildSystemVersion = $ENV{'SBS_VERSION'};

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

## the object constructor                   ##

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

sub new

{

    my $self = {};

    shift @_;

    my $actual_num = scalar(@_);

    $self->error("Expected 9 args, got $actual_num") if ($actual_num != 9);

    $self->{PLATFORM} = shift @_;

    $self->{VARIANT} = shift @_;

    $self->{TARGET_NAME} = shift @_;

    $self->{OUTPUT_DIR} = shift @_;

    $self->{UTIL} = shift @_;

    die "util not defined\n" if not $self->{UTIL};

    $self->{INPUT_FILE} = shift @_;

    $self->{UID} = shift @_;

    $self->{VID} = shift @_;

    $self->{INSTALL_DRIVE} = shift @_;

    $self->{GENERATE_PKGFILE} = 0;

    $self->{GENERATE_SISFILE} = 0;

    $self->{PKGFILE} = ($self->{OUTPUT_DIR} . "/" . $self->{TARGET_NAME} 

			. ".pkg");

    my $input_file = $self->{INPUT_FILE};

    if ($input_file)

    {

	-e $input_file or 

	    $self->{UTIL}->error("Input file '$input_file' does not exist\n");

    }

    $self->{UTIL}->detailed("variant: ", $self->{VARIANT}, "\n");

    $self->{UTIL}->detailed("target_name: ", $self->{TARGET_NAME}, "\n");

    $self->{UTIL}->detailed("output_dir: ", $self->{OUTPUT_DIR}, "\n");

    $self->{UTIL}->detailed("platform: ", $self->{PLATFORM}, "\n");

    $self->{UTIL}->detailed("variant: ", $self->{VARIANT}, "\n");

    $self->{OUTPUT_DIR} =~ m|(.*)[/\\]+.*$|;

    $self->{ROOT} = "$1\\..";

    bless($self);

    return $self;

}

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

## Class methods to access per-object data  ##

##                                          ##

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

#

# Perform environment checking

#

sub generate_prerequisites()

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $util = $self->{UTIL};

    $util->detailed("Checking environment for source generation\n");

    my $output_dir = $self->{OUTPUT_DIR};

    $util->error("$output_dir already exists") if -e $output_dir;

    mkpath($output_dir, 1, 0777);

    $util->error("Could not create $output_dir") if not -d $output_dir;

    my $input_file = $self->{INPUT_FILE};

    $util->error("'$input_file' does not exist") if not -e $input_file;

    $util->error("A UID is mandatory for generating sources") 

	if (not $self->{UID});

    my $uid = $self->{UID};

    my $vid = '';

    if (defined($self->{VID}))

    {

	my $vid = $self->{VID};

    }

    $util->detailed("Using UID and VID {$uid,$vid} respectively\n");

}

#

# Perform environment checking

#

sub pkg_prerequisites()

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $util = $self->{UTIL};

    my $localised_vendor = shift;

    my $non_localised_vendor = shift;

    my $suid = shift;

    if ($localised_vendor or $non_localised_vendor or $suid)

    {

	$util->detailed("Checking environment for pkg file generation\n");

	if (not ($localised_vendor and $non_localised_vendor and $suid))

	{

	    if (not $localised_vendor)

	    {

		$util->error("localised_vendor must be specified");

	    }

	    if (not $non_localised_vendor)

	    {

		$util->error("non_localised_vendor must be specified");

	    }

	    if (not $suid)

	    {

		$util->error("SIS UID must be specified");

	    }

	    # This is a weak check since source generation and

	    # compilation (including SIS file creation) may occur at

	    # different times.  Thus the uid may be NULL

	    my $uid = $self->{UID};

	    if ($uid eq $suid)

	    {

		$util->error("SIS file UID and Application UID ", 

			     "should not be the same");

	    }

	} 

	$self->{GENERATE_PKGFILE} = 1;

    } 

}

#

# Generate sources

#

sub generate(@)

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $output_dir = $self->{OUTPUT_DIR};

    my $util = $self->{UTIL};

    my $major = shift;

    my $minor = shift;

    my $buildnum = shift;

    my $suid = shift;

    my $localised_vendor = shift;

    my $non_localised_vendor = shift;

    $self->generate_prerequisites();

    $self->pkg_prerequisites($localised_vendor, $non_localised_vendor, $suid);

    $util->detailed("Output will be generated in $output_dir\n");

    $self->make_source_src();

    $self->make_make_src();

    $self->make_doc_src($major, $minor, $buildnum);

    if ($self->{GENERATE_PKGFILE})

    {

	$self->make_pkg_src($major, $minor, $buildnum, $suid, 

			    $localised_vendor,

			    $non_localised_vendor);

    }

}

#

# Perform environment checking

#

sub make_prerequisites(@)

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $util = $self->{UTIL};

    $util->detailed("Checking environment for building\n");

    my $output_dir = $self->{OUTPUT_DIR};

    $util->error("$output_dir does not exist") if (not -d $output_dir);

    my $platform = $self->{PLATFORM};

    $util->warning("Platform '$platform' untested.")

	if ($platform =~ /"winscw"/i and $platform =~ /"armv5"/i);

    my $variant = $self->{VARIANT};

    $util->error("$variant not supported") 

	if ($variant =~ /"urel"/i and $variant =~ /"udeb"/i);

}

#

# Perform environment checking

#

sub sis_prerequisites()

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $key = shift;

    my $certificate = shift;

    my $util = $self->{UTIL};

    if ($key or $certificate)

    {

    	$util->detailed("Checking environment for SIS file creation\n");

	# Passphrase is optional

	$util->error("Both Key and certificate must be specified") 

	    if (not ($key and $certificate));

	-e $key or $util->error("$key does not exist");    

	-e $certificate or $util->error("$certificate does not exist");

	$self->{GENERATE_SISFILE} = 1;

    }

}

#

# Build the generated source file.

#

sub make(@)

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $target_name = $self->{TARGET_NAME};

    my $output_dir = $self->{OUTPUT_DIR};

    my $platform = $self->{PLATFORM};

    my $variant = $self->{VARIANT};

    my $util = $self->{UTIL};

    my $key = shift;

    my $certificate = shift;

    my $passphrase = shift;

    $self->make_prerequisites();

    $self->sis_prerequisites($key, $certificate);

    $util->info("Building...\n");

    $util->info("Target Executable: ");

    $util->info("\\epoc32\\RELEASE\\$platform\\$variant\\${target_name}.exe\n");

    use Cwd;

    my $whence = Cwd::cwd();

    chdir "$output_dir" or$util->error("chdir $output_dir failed");

    chdir "$whence" or $util->error("chdir $whence failed");

    if ($self->{GENERATE_SISFILE})

    {

	$self->make_sis($key, $certificate, $passphrase);

    }

}

sub make_doc($)

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    use Cwd;

    my $whence = Cwd::cwd();

    my $util = $self->{UTIL};

    my $output_dir = $self->{OUTPUT_DIR};

    chdir "$output_dir" or $util->error("chdir $output_dir failed");

    $util->invoke("doxygen");

    chdir "$whence" or $util->error("chdir $whence failed");

}

#

# Generate the Doxygen configuration file.

#

sub make_doc_src()

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $major = shift;

    my $minor = shift;

    my $buildnum = shift;

    my $target_name = $self->{TARGET_NAME};

    my $output_dir = $self->{OUTPUT_DIR};

    my $util = $self->{UTIL};

    $util->info("Generating Doxygen configuration files\n");

    open(DOXYFILE, "> ${output_dir}/Doxyfile") or 

	$util->error("Could not open Doxyfile!");

    print DOXYFILE <<_____VERBATIM_____;

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

# Project related configuration options

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

PROJECT_NAME		   = $target_name

PROJECT_NUMBER		   = "V${major}.${minor}.${buildnum}"

OUTPUT_DIRECTORY	   = ./

DETAILS_AT_TOP		   = YES

TAB_SIZE		   = 8

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

# Build related configuration options

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

EXTRACT_ALL		   = YES

EXTRACT_STATIC		   = YES

CASE_SENSE_NAMES	   = YES

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

# configuration options related to the input files

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

INPUT			   = ${target_name}.cpp

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

# configuration options related to the HTML output

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

GENERATE_HTML		   = YES

GENERATE_TREEVIEW	   = YES

TREEVIEW_WIDTH		   = 250

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

# configuration options related to the LATEX output

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

GENERATE_LATEX		   = NO

_____VERBATIM_____

	close DOXYFILE;

}

#

# Generate .pkg file.

#

sub make_pkg_src()

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $util = $self->{UTIL};

    my $pkgfile = $self->{PKGFILE};

    my $platform = $self->{PLATFORM};

    my $variant = $self->{VARIANT};

    my $major = shift;

    my $minor = shift;

    my $buildnum = shift;

    my $suid = shift;

    my $localised_vendor = shift;

    my $non_localised_vendor = shift;

    $util->detailed("Generating SIS .pkg file\n");

    my $output_dir = $self->{OUTPUT_DIR};

    my $target_name = $self->{TARGET_NAME};

    my $install_drive = $self->{INSTALL_DRIVE};

    $pkgfile = "$output_dir/${target_name}.pkg";

    if (not $major and $minor and $buildnum)

    {

	$util->warning("Major Minor and build number not specifed.");

    }

    $util->detailed("Using Major Minor and build number ",

		    "{$major, $minor, $buildnum} respectively\n");

    open(PKGFILEWRITE, "> $pkgfile") or $util->error("Could not open $pkgfile!");

    print PKGFILEWRITE <<_____VERBATIM_____;

;Languages

&EN

; Header

; The application\'s major and minor version numbers are required for

; version control (e.g., AppName 3.1 specifies a major build 3, and

; minor build 1.)

; The build-number replaces the variant value which was unimplemented

; in previous versions of makesis.

; All SIS files require a UID, even if the installed components do not

; strictly require one.

; The UID value should be unique for SISAPP (SA) types of SIS file

#{"${target_name}-EN"}, ($suid), $major, $minor, $buildnum, TYPE=SA

;FILERUN, RUNINSTALL

"\\epoc32\\RELEASE\\$platform\\$variant\\${target_name}.exe" - 

"$install_drive:\\sys\\bin\\${target_name}.exe", FR, RI

; Localised vendor

%{"$localised_vendor"}

; Non-localised vendor

:"$non_localised_vendor"

_____VERBATIM_____

	close PKGFILEWRITE;

}

#

# Clean up generated files.

#

sub clean($)

{

    my $self = shift;

    die "self not defined\n" if (not defined($self));

    my $reallyclean = (shift @_ > 1);

    my $platform = $self->{PLATFORM};

    my $variant  = $self->{VARIANT};

    my $target_name = $self->{TARGET_NAME};

    my $output_dir = $self->{OUTPUT_DIR};

    my $util = $self->{UTIL};

    $util->error("Unknown target") if not $target_name;

    $util->info("Attempting to clean for '$target_name'\n");

    use Cwd;

    my $whence = Cwd::cwd();

    if ($reallyclean)

    {

		if ($BuildSystemVersion == "2") 

		{

			if (not -e "$output_dir/bld.inf")

			{

				if (not -d $output_dir)

				{

					mkpath($output_dir, 1, 0777);

					-d $output_dir or $self->error("Could not create $output_dir");

				}

				## Generate the project files so we can clean for the

				## specifed platform and variant							

				$self->make_make_src();				

			}

			$util->info("Cleaning for platform: $platform, variant: $variant\n");

			Cwd::cwd() eq "$output_dir" or 

				chdir "$output_dir" or $util->error("chdir $output_dir failed");

			my $platformConfig = "$platform"."_"."$variant";

			$util->invoke("sbs -c $platformConfig reallyclean");			

			$util->info("System cleaned for platform: $platform, ",

					"variant: $variant\n");

		}

		else

		{

			if (not -e "$output_dir/abld.bat")

			{

				if (not -d $output_dir)

				{

					mkpath($output_dir, 1, 0777);

					-d $output_dir or $self->error("Could not create $output_dir");

				}

				## Generate the project files so we can clean for the

				## specifed platform and variant			

				$self->make_make_src();

				chdir "$output_dir" or $util->error("chdir $output_dir failed");

				$util->invoke("bldmake bldfiles");

			}

			$util->info("Cleaning for platform: $platform, variant: $variant\n");

			Cwd::cwd() eq "$output_dir" or 

				chdir "$output_dir" or $util->error("chdir $output_dir failed");

			$util->invoke("abld reallyclean $platform $variant");

			$util->invoke("bldmake clean");