#! perl

use strict;

use Getopt::Long;

# TODO:

# Improve performance by not accessing P4 for every source line in every MRP file

# Handle situation where clean-src dir is missing by accessing MRP file from Perforce

# Use autobuild database to get perforce information directly?

# What should we do about change C reverts change B which reverted change A? 

#  => Hope C has a good description, as this implementation will discard both A and B descriptions.

#note: currently relies on existence of perforce report of previous build

# Parameters passed to script

my $Product = shift;           	# e.g. 9.3

my $Platform = shift;          	# e.g. cedar       

my $CurentBuild = shift;       	# e.g. 03935

my $CurrentCL = shift;         	# e.g. 775517

shift;				# e.g. 03935_Symbian_OS_v9.3

my $CurrCodeLine = shift;   	# e.g. //epoc/master/

my $PreviousBuild = shift;	# the build number of the previous release (eg 03925)

my $LogDirs = shift;           	# e.g. \\builds01\devbuilds

my $CleanSourceDir = shift;	# e.g. M:\clean-src (synched file from perforce)

my $debug = 0; 		       	# set to 1 to print debug logfile and progress information

GetOptions(

  	'v' => \$debug);

# Derived parameters

my $CurrBldName = "$CurentBuild\_Symbian_OS_v$Product";	# e.g. 03935_Symbian_OS_v9.3

# Global variables

my $PreviousLogDir;		# location of the logs associated with the previous release build 

my $PrevFileAndPath;		# name of the previous release build's perforce report and its location

my $PrevBldName;                # e.g. 03925_Symbian_OS_v9.3

my $MainLineCL = 0;             # the CL of the build from which the current build

                                #    was branched if it is on a delivery branch

my $MainLineLine;               # the codeline of the build from which the current

                                #    build was branched if on a delivery branch

my %allDefects;			# hash containing all of the defect fixes

my %allBreaks;			# hash contains all of the delivered breaks

my %changeToComponents;	# hash containing lists of components affected by a given change

my %reverted;			# hash of reverted changelists

# Tidy up directories to ensure they are in a standard format

$CurrCodeLine =~ s/[^\/]$/$&\//;# ensure a trailing fwdslash for codeline

$LogDirs =~ s/\\$//;		# ensure no trailing back slash for codeline

$CleanSourceDir =~ s/\\$//;	# ensure no trailing back slash for codeline

# add information to the debug log if the debug flag is set

if ($debug)

{

    # Open an error log

    open ERRORLOG, "> Errorlog.txt";

    print ERRORLOG <<"END";

Inputs:

Product: $Product

Platform: $Platform

Current build: $CurentBuild

Current build CL: $CurrentCL

Current Build Name: $CurrBldName

Previous Build: $PreviousBuild

Log Directory: $LogDirs

Clean Source Dir: $CleanSourceDir

Errors:

END

}

# If the previous release was from a delivery branch, then use the build from 

# from which the delivery branch was created by removing the letters (changes

# on the files on the branch will also have been made on the main codeline)

$PreviousBuild =~ s/[a-z]+(\.\d+)?//;

# If the current build is on a delivery branch, then store the information about

# the build from which it was branched as it will be necessary to get the descriptions

# from perforce for versions on the branch and versions on the main codeline up to 

# where the branch was created separately

if ($CurentBuild =~ /[a-z]+/)

{

    my $MainLineBuild = $CurentBuild;

    $MainLineBuild =~ s/[a-z]+(\.\d+)?//;

    # There is insufficient information here anyway, e.g. if M09999 failed and we did 

    # M09999.01 as the original candidate, then there is no way of telling the tool

    my $MainLineBldName = "$MainLineBuild\_Symbian_OS_v$Product";

    my $MainLinePerforce = "$LogDirs\\$MainLineBldName\\logs\\$MainLineBuild\_$Product" . "PC_Perforce_report.html";

    ($MainLineCL, $MainLineLine) = GetPrevCodelineandCL($MainLinePerforce, $Platform);

}

# Construct the previous build name

$PrevBldName = "$PreviousBuild\_Symbian_OS_v$Product";

# Construct the name of the peforce report file for the previous external release

# to look similar to this:  03925_9.3PC_Perforce_report.html

my $PerforceReport = $PreviousBuild."_".$Product."PC_Perforce_report.html";

# Look for $PerforceReport in the build logs directory and the log archive directory

$PreviousLogDir = "$LogDirs\\$PrevBldName\\logs\\";

$PrevFileAndPath = $PreviousLogDir.$PerforceReport;

if (! -d $CleanSourceDir)

{

    # if the report is found in neither directory then die

    if ($debug==1)

    {

      print ERRORLOG "Clean-src directory does not exist! ($CleanSourceDir)\n";

    }

    die "ERROR: Clean-src directory does not exist";

}

if (! -e $PrevFileAndPath)

{ 

    $PreviousLogDir = "$LogDirs\\logs\\$PrevBldName\\";  

    $PrevFileAndPath = $PreviousLogDir.$PerforceReport;

}

if (! -e $PrevFileAndPath)

{

    # if the report is found in neither directory then die

    if ($debug==1)

    {

      print ERRORLOG "Could not find Perforce report of previous external release! ($PrevFileAndPath)\n";

    }

    die "ERROR: Cannot find previous Perforce report";

}

# Parse the Perforce report to extract the previous build's change list and codeline path

my ($PreviousCL, $PrevCodeLine) = GetPrevCodelineandCL($PrevFileAndPath, $Platform);

# Create the path of the current build's log directory

my $CurrentLogDir = "$LogDirs\\$CurrBldName\\logs\\";

# Obtain the component lists (arrays are passed back by reference, each element containing a component

# name separated by one or more spaces from its associated mrp file as it appears in the component files)

my ($GTprevCompList, $GTlatestCompList, 

    $TVprevCompList, $TVlatestCompList) = GetGTandTVcomponentLists($CurrentLogDir, $PreviousLogDir);

# Consolidate the lists of components in to two hashes: one for the current build and one for the previous

# release build. These contain an index to distinguish between GT and TechView components and another index

# with the names of the components. The mrp files are the elements being indexed.

my ($PrevMRP, $CurrMRP) = CreateMRPLists($GTprevCompList, 

                                         $GTlatestCompList, 

                                         $TVprevCompList, 

                                         $TVlatestCompList);

# For each component, extract its source directories from its MRP file and add the information to a list 

my (@ComponentAndSource) = ProcessLists($Product, 

                                        $PrevCodeLine, 

                                        $Platform , 

                                        $PrevMRP, 

                                        $CurrMRP, 

                                        $PreviousCL,

                                        $CleanSourceDir);

# Put together the HTML file using the components list with their associated source files

(my $ChangesFileHTML) = CreateReleaseNotes($Product, 

                                           $CurrCodeLine,

                                           $MainLineLine,

                                           $PreviousCL, 

                                           $CurrentCL, 

                                           $MainLineCL,

                                           @ComponentAndSource);

if ($debug)

{

    close ERRORLOG;

}

print "FINISHED!! - $ChangesFileHTML\n";

exit;

#

#

# Gets component lists from the builds' log directories. Reads the contents 

# of the files in to arrays and returns references to these arrays.

#

# Inputs:  Current and previous build's logfile locations

# Outputs: Arrays containing contents of previous and current GTcomponents.txt

#          and TVcomponents.txt files (list of components with their associated

#          mrp files). An example array elment might contain:

#          "ChatScripts	\sf\os\unref\orphan\comtt\chatscripts\group\testtools_chatscripts.mrp"

#

sub GetGTandTVcomponentLists

{

    my ($CurrLogPath, $PrevLogPath) = @_;

    # Data to return: array of refs to arrays of contents of files

    my @return;

    # Files to read from

    my @FileNames = (

        $PrevLogPath."GTcomponents.txt",

        $CurrLogPath."GTcomponents.txt",

        $PrevLogPath."TechViewComponents.txt",

        $CurrLogPath."TechViewComponents.txt",

    );

    foreach my $FileName (@FileNames)

    {

        if (!open(DAT, $FileName)) 

        { 

            if ($debug)

            {

                print ERRORLOG "Could not open $FileName!\n";

            }

            die "ERROR: Could not open $FileName: $!";

        }

        push @return, [<DAT>];

        close DAT;

    }

    return @return;

}

#

#

# Creates two list of components and their associated mrp files - one for the previous 

# build and one for the current build

#

# Inputs: the contents of the GT and TV components files

# Outputs: Two lists of components and their mrp files, one from the previous build

#          and one from the current build

#

#

sub CreateMRPLists

{

    # references to the contents of the components files              

    my $GTprevFile = shift; 

    my $GTlatestFile = shift; 

    my $TVprevFile = shift; 

    my $TVlatestFile = shift; 

    my %PreviousMrps;    #Hash of all Components and their MRP file locations for the previous build

    my %CurrentMrps;     #Hash of all Components and their MRP file locations for the current build

    # Add mrp files to a hash indexed under GT or TV and by component names 

    foreach my $case (

        [\%PreviousMrps, 'GT', $GTprevFile],

        [\%CurrentMrps,  'GT', $GTlatestFile],

        [\%PreviousMrps, 'TV', $TVprevFile],

        [\%CurrentMrps,  'TV', $TVlatestFile],

        )

    {

        foreach my $element (@{$case->[2]})

          {

            if ( $element =~ /(.*)\s+(\\sf\\.*)$/ )

            {

                ${$case->[0]}{$case->[1]}{uc($1)} = lc($2);

            }

          }

    }

    return \%PreviousMrps, \%CurrentMrps;

}

#

#

# Use the contents of the MRP files to create a single list containing the GT and TechView

# components paired with associated source files.

#

# Inputs: Product, Codeline, Previous Codeline, Platform, Both lists of mrps, 

#         Previous Changelist number, Build machine's clean source directory which

#         contains copies of the current build's mrp files.

# Outputs: Array containing all components and their source locations

#

#

sub ProcessLists

{

    my $Product = shift;

    my $PrevCodeLine = shift;

    my $Platform = shift;

    my $PreviousMrps = shift;   #Hash of MRPs at the Previous changelist number

    my $CurrentMrps = shift;    #Hash of MRPs at the Current changelist number

    my $PrevCL = shift;

    my $CleanSourceDir = shift;

    my @PrevGTMrpComponents;    #Array of GT Components at Previous changelist number

    my @CurrGTMrpComponents;    #Array of GT Components at Current changelist number

    my @PrevTVMrpComponents;    #Array of TV Components at Previous changelist number

    my @CurrTVMrpComponents;    #Array of TV Components at Current changelist number

    # Isolate hashes

    my $CurrGT = $CurrentMrps->{'GT'};

    my $CurrTV = $CurrentMrps->{'TV'};

    my $PrevGT = $PreviousMrps->{'GT'};

    my $PrevTV = $PreviousMrps->{'TV'};

    # Append the location of the clean source directory for the current build

    # to all the mrp files. If a file appears only in the previous build (i.e.  

    # a component has been removed) its location in perforce is later substituted

    # in place of this path

    foreach my $component (sort keys %$CurrGT)

    {

	$CurrGT->{$component} =~ s|\\sf|$CleanSourceDir|ig;

        $CurrGT->{$component} =~ s|\\|\/|g;

	push @CurrGTMrpComponents, "$component\t$CurrGT->{$component}";

    }

    foreach my $component (sort keys %$CurrTV)

    {

	$CurrTV->{$component} =~ s|\\sf|$CleanSourceDir|ig;

	$CurrTV->{$component} =~ s|\\|\/|g;

	push @CurrTVMrpComponents, "$component\t$CurrTV->{$component}";

    }

    foreach my $component (sort keys %$PrevGT)

    {

	$PrevGT->{$component} =~ s|\\sf|$CleanSourceDir|ig;

	$PrevGT->{$component} =~ s|\\|\/|g; 

	push @PrevGTMrpComponents, "$component"."\t"."$PrevGT->{$component}";

    }

    foreach my $component (sort keys %$PrevTV)

    {

	$PrevTV->{$component} =~ s|\\sf|$CleanSourceDir|ig;

	$PrevTV->{$component} =~ s|\\|\/|g;

	push @PrevTVMrpComponents, "$component"."\t"."$PrevTV->{$component}";

    }

    # add any components that appear only in the previous build's list to the 

    # current build's list with its location in perforce.

    foreach my $PrevGTComp(@PrevGTMrpComponents)

    {

    	my $match = 0;

    	#Compare component lists to ensure they contain the same components.

    	foreach my $CurrGTComp(@CurrGTMrpComponents)

    	{

	    $match = 1 if($PrevGTComp eq $CurrGTComp);

	}

	#If a component is found in the Previous list which isn't in the Current list, 

        #then insert it into the Current list with the previous build's path

	if($match == 0)

        {

            $PrevGTComp =~ s|\/|\\|g;

            $PrevGTComp =~ s|\Q$CleanSourceDir\E\\|$PrevCodeLine|ig;

            $PrevGTComp =~ s|\\|\/|g;

            push @CurrGTMrpComponents, $PrevGTComp;    

        }

    }

    # add any components that appear only in the previous build's list to the 

    # current build's list with its location in perforce.

    foreach my $PrevTVComp(@PrevTVMrpComponents)

    {

    	my $match = 0;

    	#Compare component lists to ensure they contain the same components.

    	foreach my $CurrTVComp(@CurrTVMrpComponents)

    	{

	    $match = 1 if($PrevTVComp eq $CurrTVComp);

	}

	#If a component is found in the Previous list which isn't in the Current list, 

        #then insert it into the Current list

        if($match == 0)

        {

           $PrevTVComp =~ s|$CleanSourceDir|$PrevCodeLine|ig;

	   push @CurrTVMrpComponents, $PrevTVComp;

        }

    }

    # Combine current GT and TV components, with a boundary marker

    my @CurrMrpComponents = (@CurrGTMrpComponents, "**TECHVIEWCOMPONENTS**", @CurrTVMrpComponents);

    # Swap the back slashes for forward slashes

    $CleanSourceDir =~ s/\\/\//g;

    $PrevCodeLine =~ s/\\/\//g;

    #Use the MRP file for each component to obtain the source directory locations

    my @ComponentAndSource;

    foreach my $ComponentLine(@CurrMrpComponents)

    {

        #Array to hold mrp file contents

        my @MrpContents;

        # if the file is in the Clean Source Directory then read its contents from there

	if($ComponentLine =~ /.*(\Q$CleanSourceDir\E.*)/)

	{ 

	    my $MrpFile = $1;

	    $MrpFile =~ s/\.mrp.*$/\.mrp/;  #drop any trailing spaces or tabs

            if (-e $MrpFile)

            {

                open(FILE, $MrpFile);

                @MrpContents=<FILE>;

                close FILE;

            }          

	}

        elsif($ComponentLine =~ /.*(\Q$PrevCodeLine\E.*)/)

        {

	    # If a component has been removed between the previous build and the current one then 

	    # its MRP file will only exist at the PrevCL

            @MrpContents = `p4 print -q $1...\@$PrevCL`; # access Perforce via system command 

        }

	elsif($ComponentLine =~ /\*\*TECHVIEWCOMPONENTS\*\*/)

	{

	    push @MrpContents, $ComponentLine;

	}

	#Construct an array containing components in uppercase followed by 

        #all their sourcelines in lowercase

	foreach my $line(@MrpContents)

	{

	    if($line =~ /^component\s+(.*)/i)

	    {

		my $ComponentName = uc($1);

		push @ComponentAndSource, $ComponentName;

	    }

	    elsif($line =~ /^source\s+(.*)/i)

	    {

		my $Source = lc($1);

		$Source =~ s/\\/\//g;

		$Source =~ s|/sf/||;

		$Source =~ s|/product/|$Platform/product|ig;

		push @ComponentAndSource, $Source;

            }

	    elsif($line =~ /TECHVIEWCOMPONENTS/)

	    {

		push @ComponentAndSource, $line;

	    }

	}

    }

    return @ComponentAndSource;

}

#

# Format the changes associated with a component

#

# Inputs: 

#   reference to hash of change descriptions by changelist number, 

#	component name, 

#   reference to (formatted) list of names of changed components

#   reference to list of names of unchanged components

#

# Updates: 

#   adds component name to changed or unchanged list, as appropriate

#

sub PrintComponentDescriptions(\%$\@\@)

{

	my ($Descriptions,$CompName,$ChangedComponents,$UnchangedComponents) = @_;

	if (scalar keys %{$Descriptions} == 0)

	{

		# no changes in this component

		push @{$UnchangedComponents}, $CompName;

		return;

	}

	push @{$ChangedComponents}, "<a href=\"#$CompName\">$CompName</a>";

    # Format the changes for this component

	my @CompLines = ("<h2><a name=\"$CompName\"/>$CompName</h2>");

    foreach my $change (reverse sort keys %{$Descriptions})

    {

        # Heading for the change description

        my $summary = shift @{$$Descriptions{$change}};

        $summary =~ s/(on .*)\s+by.*//;

        $summary = "<a href=\"#$change\">Change $change</a> $1";

        push @CompLines, "<p><a name=\"#$CompName $change\"/><b>$summary</b>";

        # Body of the change description

        push @CompLines, "<pre>";

        push @CompLines,

            grep { $_; }	# ignore blank lines

            @{$$Descriptions{$change}};

        push @CompLines, "</pre>";

		# record the component in the cross-reference table

        push @{$changeToComponents{$change}}, "<a href=\"#$CompName $change\">$CompName</a>";

    }

	&PrintLines(@CompLines);

}

#

#

# Creates the Release Notes html file by extracting the perforce descriptions for each

# change that has been made to the components

#

# Inputs: Product, Source path of the product (i.e.//EPOC/master), the source path on the

#         main codeline if a delivery branch is being used, Previous changelist,

#         Current changelist, changelist from which the branch was made if a branch is being 

#         used, array of components and their source.

# Outputs: Release Notes html file.

#

# Algorithm:

#   Loop through the component&source array

#       Determine whether a boundary, component name, a source dir

#       If a source dir, query perforce to see what changelists have affected it in the period that we're interested in

#       If it has been affected, add the changelist to this component's changelists, unless it's already there

#

#   This is rather inefficient :-(

#

sub CreateReleaseNotes

{

    my $Product = shift;

    my $Srcpath = shift;

    my $MainLinePath = shift;

    my $PrevCL = shift;

    my $CurrentCL = shift;

    my $BranchCL = shift;

    my @ComponentAndSource = @_;

    #Reset all arrays to NULL

    my @PrevGTMrpComponents = ();

    my @CurrGTMrpComponents = ();

    my @PrevTVMrpComponents = ();

    my @CurrTVMrpComponents = ();

    my @CurrMrpComponents = ();

    my @Components = ();

    my @UnchangedComponents = ();

    my @ChangedComponents = ();

    my %changeProcessed = ();		# hash of changelists processed for this component

    my %changeToDescription = ();	# hash of descriptions for non-reverted changelists

    $PrevCL++;     # increment changelist number so we don't include the very first submission 

                   #  - it would have been picked up in the last run of this script