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

# This script builds ROMs which are specified in a supplied XML file
# To use this script \epoc32\tools\buildrom must be installed on the drive
# with \epoc32\tools in the path

# Note: The TargetBoard attribute is no longer used but is still needed because of the structure of this script!

use strict;
use XML::Simple;
use Getopt::Long;
use Cwd;
use Cwd 'abs_path';
use File::Copy;
use File::Path;

# Get command line arguments
my ($romspec, $boards, $roms, $logdir, $buildnum, $publish, $help, $version) = ProcessCommandLine();

Usage() if ($help);
Version() if ($version);

die "Romspec xml file must be specified using the -romspec option\n" if (!$romspec);

# Construct arrays of boards and roms if they were specified
my @boards = split /,/, $boards if ($boards);
my @roms = split /,/, $roms if ($roms);

# Use the XML::Simple module to parse the romspec and pass the result
# into the $Roms hash reference
my $xml = new XML::Simple;
my $Roms = $xml->XMLin($romspec);

my $RomList = %$Roms->{'Rom'};

my $RomBuildStage = 1;

foreach my $rom (sort keys %$RomList)
{
    my $board = $RomList->{$rom}->{'TargetBoard'};
    if( (@boards == 0 and @roms == 0) or grep $rom, @roms or grep $board, @boards)
    {
        BuildRom($RomBuildStage, $RomList, $rom, $logdir, $buildnum ,$publish);
        $RomBuildStage++;
    }
}

#####################################################
#### Run buildrom on the specified ROM using ########
#### info from the romspec.xml               ########
#####################################################
sub BuildRom
{
    my $Stage = shift;  # BuildRom stage
    my $RomList = shift;  # Hash of the romspec.xml
    my $rom = shift;   # Rom to be built
    my $logdir = shift;  # logs directory
    my $buildnum = shift;  # build number
    my $publish = shift;   # Publish Location
    my $type = $ENV{Type}; # type of Build Master or Release
    my $builddir = $ENV{BuildDir}; # Build Directory
    my $Epocroot = $ENV{EPOCROOT}; # EpocRoot;
    my $InFileList="";  # i.e. Platsec, Techview, obyfiles
    my $XmlFileList="";
    my $MacroList="";   # for the buildrom -D option
    my $TargetBoard = $RomList->{$rom}->{'TargetBoard'};
    my $ImageFile = " -o".$RomList->{$rom}->{'ImageFile'}->{'name'}; # for the buildrom -o option
 
    # Construct the list of InFiles to pass to buildrom
    my $InFiles = %$RomList->{$rom}->{'InFile'};
    foreach my $infile (sort keys %$InFiles)
    {
        if ($infile eq "name")
        {
            $InFileList = " ".$InFiles->{'name'} unless (lc($InFiles->{'name'}) eq lc($TargetBoard));
        }
        else
        {
            $InFileList .= " ".$infile unless(lc($infile) eq lc($TargetBoard));
        }
    }
    my $RomXmlFlag='-f';
    my $XmlFiles = %$RomList->{$rom}->{'XMLFile'};
    foreach my $XmlFlags (keys %$XmlFiles)
    {
        if ($XmlFlags eq "flag")
        {
          $RomXmlFlag= $XmlFiles->{'flag'};
        }
    }
    foreach my $XmlFile (keys %$XmlFiles)
    {
        if ($XmlFile eq "name")
        {
            $XmlFileList = "$RomXmlFlag"."$Epocroot"."epoc32\\rom\\include\\".$XmlFiles->{'name'};
        }
        else
        {
            $XmlFileList .= "$RomXmlFlag"."$Epocroot"."epoc32\\rom\\include\\".$XmlFile unless(lc($XmlFile) eq lc($TargetBoard));
        }
    }
    
    # Get the ROM macro if one is defined
    if ( defined $RomList->{$rom}->{'Macro'} )
    {
        if (defined $RomList->{$rom}->{'Macro'}->{'name'} )
        {
            if ( $RomList->{$rom}->{'Macro'}->{'value'} ne "" )
            {
                $MacroList = " -D".$RomList->{$rom}->{'Macro'}->{'name'}."=".$RomList->{$rom}->{'Macro'}->{'value'};
            }
            else
            {
                $MacroList = " -D".$RomList->{$rom}->{'Macro'}->{'name'};
            }
        }
        else
        {
            my $Macros = %$RomList->{$rom}->{'Macro'};
            foreach my $macro (keys %$Macros)
            {
                if ( $Macros->{$macro}->{'value'} ne "" )
                {
                    $MacroList .= " -D".$macro."=".$Macros->{$macro}->{'value'};
                }
                else
                {
                    $MacroList .= " -D".$macro;
                }
            }
        }
    }
    
    # Call buildrom
        my $buildrom_command = "buildrom $InFileList $MacroList $XmlFileList $ImageFile 2>&1";
        my $gHiResTimer = 0;
        if (eval "require Time::HiRes;")
        {
            $gHiResTimer = 1;
        }
        else
        {
            print "Cannot load HiResTimer Module\n";
        }
        open TVROMLOG, ">> $logdir\\techviewroms$buildnum.log";
        print TVROMLOG "===------------------------------------------------\n";
        print TVROMLOG "-- Stage=$Stage\n";
        print TVROMLOG "===----------------------------------------------\n";
        print TVROMLOG "-- Stage=$Stage started ".localtime()."\n";
        print TVROMLOG "=== Stage=$Stage == Build $rom\n";
        print TVROMLOG "-- Stage=$Stage == $TargetBoard $InFileList\n";
        print TVROMLOG "-- $buildrom_command\n";
        print TVROMLOG "-- MetaromBuild Executed ID $Stage $buildrom_command \n";
        print TVROMLOG "++ Started at ".localtime()."\n";
        if ($gHiResTimer == 1)
        {
            print TVROMLOG "+++ HiRes Start ".Time::HiRes::time()."\n";
        }
        else
        {
            # Add the HiRes timer unavailable statement
            print TVROMLOG "+++ HiRes Time Unavailable\n";
        }
        my $command_output = `$buildrom_command`;
        print TVROMLOG $command_output;
        if ($?)
        {
            print TVROMLOG "ERROR: $buildrom_command returned an error code $?\n";
        }
        if (($command_output =~m/\d\sFile/g) and ($command_output!~/Failed/ig) and ($command_output!~/Unsucessful/ig))
        {
            print TVROMLOG "Rom Built Sucessfully\n";
        }
        else
        {
            print TVROMLOG "ERROR: $buildrom_command failed .Please check log techviewroms$buildnum.log for details\n";
        }
        if ($gHiResTimer == 1)
        {
            print TVROMLOG "+++ HiRes End ".Time::HiRes::time()."\n";
        }
        else
        {
            # Add the HiRes timer unavailable statement
            print TVROMLOG "+++ HiRes Time Unavailable\n";
        }
        print TVROMLOG "++ Finished at ".localtime()."\n";
        print TVROMLOG "=== Stage=$Stage finished ".localtime()."\n";
        close TVROMLOG;
        
        # Publishing of Logs and Roms#####################
        my $ImageFileXML = $ImageFile ;
        $ImageFileXML =~s/^\s-o//i;
        $ImageFileXML =~/(.*\d.techview)/;
        my $ImageFileXMLresult = $1;
        my $cwdir = abs_path ( $ENV { 'PWD' } );
        $cwdir =~s/\//\\/g;
        $rom =~ /(\w+).*/;
        my $data = $1;
        if(($publish ne ""))
        {
            if($rom =~ /(\w+).*/)
            {   
                my $data = $1;
                if(not -d "$publish\\$1")
                    {
                        mkpath "$publish\\$1" || die "ERROR: Cannot create $publish\\$1"; # If folder doesnt exist create it 
                    }
                    opendir(DIR, $cwdir) || die "can't opendir $cwdir: $!";
                    my @file_array =readdir(DIR);
                foreach ($ImageFileXMLresult)
                {
                    foreach my $ImageFileConcat (@file_array)
                    {
                        $ImageFileConcat =~/(.*\d.techview)/;
                        my  $Image = $1;
                        
                        if ($ImageFileXMLresult eq $Image)
                        {
                            copy ("$cwdir\\$ImageFileConcat" , "$publish\\$data\\");# or die "Cannot copy file:$!";
                        }                   
                    }
                    closedir DIR;
                }   
            }
        }
        else
        {
            print"Publish Option not used \n";
        }
}

########################################
##### Process the command line #########
########################################
sub ProcessCommandLine
{
    my ($romspec, $boards, $roms, $publish, $help, $version);

    GetOptions('romspec=s' => \$romspec,
               'roms=s' => \$roms,
               'boards=s' => \$boards,
               'logdir=s' => \$logdir,
               'buildnum=s' => \$buildnum,
               'publish=s' => \$publish,
               'help' => \$help,
               'version' => \$version)|| die Usage();
    
    return ($romspec, $boards, $roms, $logdir, $buildnum, $publish, $help, $version);
}


sub Usage
{
    print <<USAGE_EOF;

Usage
-----
perl metarombuild.pl -romspec <romspec xml file> [options]

 When no options are specified, all ROMs specified in the romspec wil be built.
 
 Options:
    -logdir <path to logs directory>
    -buildnum <build number>
    -publish <location of path where rom logs will be published >
    -help
    -version

USAGE_EOF
exit 0;
}

sub Version
{
    print <<VERSION_EOF;

metarombuild.pl v1.0
Copyright (c) 2005-2009 Nokia Corporation. All rights reserved.
    
VERSION_EOF
exit 0;
}