#
# Copyright (c) 2009-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:
#
# Finds MMP paths from component makefiles and forwards them to MMP parser
#
#!perl -w
use FindBin;
my $trace_compiler_path;

BEGIN
{
  # Get current directory as TraceCompiler path
  $trace_compiler_path = $FindBin::Bin; # e.g. X:/epoc32/tools
  $trace_compiler_path =~ s/\\/\//g; # Replace all "\" with "/"
  $trace_compiler_path =~ s/\/$//; # Remove possible trailing slash
}

use lib $trace_compiler_path;

use strict;
use env;
use Cwd;
use tracecompiler;
use tracecompiler_mmp_data;

# EPOC root is two levels down from TraceCompiler level
my $epocroot = tracecompiler::concatenatePath($trace_compiler_path, "../../");
$epocroot =~ s/\/$//; # Remove possible trailing slash
my $drive = substr($epocroot, 0, 2);
my $build_target;
my $project_name;
my $action = "RUN";

# Get Java command or EXIT if not found
my $java_command = tracecompiler::getJavaCommand();

if (not defined $java_command)
{
  print STDERR "Java 1.5 or newer required!\n";
  exit;
}

#-------------------------------------------------------
# Go through command line arguments
#-------------------------------------------------------
while ( @ARGV )
{
  my $arg = shift(@ARGV);
  
  # Print version information
  if ($arg eq "-v")
  {
    my $version = tracecompiler::getTraceCompilerVersion();
    print $version;
    exit;
  }
  # Clean TraceCompiler generated files
  elsif ($arg eq "-clean")
  {
    $action = "CLEAN";
  }
  # Finalize TraceCompiler running
  elsif ($arg eq "-final")
  {
    $action = "FINAL";
  }
  # Build target (e.g. armv5)
  elsif (not defined $build_target)
  {
    $build_target = $arg;
  }
  # Project name (e.g. MyComponent)
  else
  {
    $project_name = $arg; 
  }
}

#-------------------------------------------------------
# Build target must now be defined or print usage info
#-------------------------------------------------------
if (not defined $build_target)
{
  my $version = tracecompiler::getTraceCompilerVersion();
  print $version;
  print "\nUsage: tracecompiler.pl build_target in the folder containing bld.inf. bldmake bldfiles must be run before this.\n";
  print "Example: tracecompiler.pl armv5\n";
  exit;
}

my $return_string = "";

#-------------------------------------------------------
# Find component makefile path from abld.bat
#-------------------------------------------------------
tracecompiler::debugTraceCompilerVersion();
tracecompiler::debugMsg("Find component makefile path from abld.bat");
open(ABLD, "<abld.bat") or die $!;
my $makefile;
while (<ABLD>)
{
  if (/ABLD.PL/)
  {
    my $makefilepath = $_;
    $makefilepath =~ s/perl -S ABLD.PL "(.*)\\" .*$/$1/;
    chop($makefilepath);
    
    # Change all "\" characters to "/"
    $makefilepath =~ s/\\/\//g;
    
    $makefilepath = "$epocroot/epoc32/build".$makefilepath;
    $makefile = $makefilepath.$build_target.".MAKE";
  }
}
close ABLD or die $!;

#-------------------------------------------------------
# Find project makefile paths from component makefile
#-------------------------------------------------------
my @projectmakefiles;
my $mmps;

tracecompiler::debugMsg("Find project makefile paths from component makefile $makefile");

open(MAKEFILE, "<$makefile") or (print STDERR "Cannot open makefile $makefile\n" and exit);
while (<MAKEFILE>)
{
  my $line = $_;
    
  if ($line =~ /\"([^\"]+?)\"\s+\"PRJ_.*MMPFILES\s+MMP\"\s+\"([^\"]+?)\"/i)
  {
    my $bldinf = $1;
    my $mmp = $2;
    
    tracecompiler::debugMsg("Found BLD file: $bldinf");
    
    # Remove bld.inf from the end of the path
    $bldinf =~ s/(.*)[\\\/].*/$1\//;
    
    my $mmp_file = tracecompiler::concatenatePath($bldinf, $mmp);
        
    # Change all "//" to "/"
    $mmp_file =~ s/\/\//\//g;
    
    # If .mmp is missing from the end, add it
    if ($mmp_file !~ /\.mmp$/i)
    {
      $mmp_file .= ".mmp";
    }
        
    tracecompiler::debugMsg("Found MMP file: $drive$mmp_file\n");
    
    # If project name is defined, only add that MMP to the list of mmp files
    if (defined $project_name)
    {
        if ($mmp_file =~ /($project_name.mmp)$/i)
        {
          $mmps .= $drive . $mmp_file . " ";
        }       
    }
    else
    {
      $mmps .= $drive . $mmp_file . " ";  
    }
  }

}
close MAKEFILE or die $!;

#-------------------------------------------------------
# Call the MMP parser for each MMP (or clean / final)
#-------------------------------------------------------
if (defined $mmps)
{
  foreach my $mmp (split(" ", $mmps))
  {
    # Pass MMP file path to Parse MMP
    if ($action eq "RUN")
    {
      my $command = "perl $trace_compiler_path/tracecompiler_parse_mmp.pl $mmp";
      tracecompiler::debugMsg("Call the MMP parser. Command: $command\n");
      print qx($command);
    }
    
    # Clean files using this MMP
    elsif ($action eq "CLEAN")
    {
    	my $mmpObject = tracecompiler_mmp_data->new($mmp);
      cleanTraceCompilerFiles($mmpObject);
    }
    
    # Finalize files using this MMP
    elsif ($action eq "FINAL")
    {
    	my $mmpObject = tracecompiler_mmp_data->new($mmp);
      finalizeTraceCompilerRun($mmpObject);
    }
  }
}
else
{
  tracecompiler::debugMsg("Could not find any MMP files!");
}





#-------------------------------------------------------#
#-------------------------------------------------------#
#--------------------SUBROUTINES------------------------#
#-------------------------------------------------------#
#-------------------------------------------------------#

#-------------------------------------------------------
# Cleans TraceCompiler generated files
#-------------------------------------------------------
sub cleanTraceCompilerFiles
{
  tracecompiler::debugMsg("Clean TraceCompiler Files");
  my $mmpObj = $_[0];
  if($mmpObj->{tracespaths}) {
  	foreach my $tracesFolder (@{$mmpObj->{tracespaths}})
  	{
    	if (-e $tracesFolder and opendir(DIR, $tracesFolder))
    	{
      	while (defined(my $file = readdir(DIR)))
      	{
        	# Delete files ending with *Traces.h
        	if ($file =~ /Traces\.h$/i)
        	{
          	print "Cleaning: " . $tracesFolder . "/" . $file . "\n";
          	unlink $tracesFolder . "/" . $file || print $!;
        	}
        	# Delete cache files
        	elsif ($file =~ /\.cache$/i)
        	{
          	print "Cleaning: " . $tracesFolder . "/" . $file . "\n";
          	unlink $tracesFolder . "/" . $file || print $!;
        	}
      	}
      	closedir(DIR);
    	}
 	 }
 	}
  
  tracecompiler::debugMsg("Cleaning TraceCompiler Files ready\n");
  
  # Finalize TraceCompiler run
  finalizeTraceCompilerRun($mmpObj);
}

#-------------------------------------------------------
# Finalizes TraceCompiler run
#-------------------------------------------------------
sub finalizeTraceCompilerRun
{
	tracecompiler::debugMsg("Finalize TraceCompiler Run");
	my $mmpObj = $_[0];
	if($mmpObj->{tracespaths}) {
	foreach my $tracesFolder (@{$mmpObj->{tracespaths}})
	{
		my $defFile = $tracesFolder . "/" . "OstTraceDefinitions.h";
		# Open OstTraceDefinitions.h and read stuff to array
		if (-e $defFile and open(FILE,"<$defFile"))
		{
			my @lines = <FILE>;
			close(FILE);

			# Write stuff back to OstTraceDefinitions.h
			open(FILE,">$defFile") || exit;
			foreach my $line (@lines)
			{
				# Comment out the define
				$line =~ s/(.*)#define OST_TRACE_COMPILER_IN_USE/\/\/ #define OST_TRACE_COMPILER_IN_USE/;
				print FILE $line;
			}
			close(FILE);
		}
	}
}

tracecompiler::debugMsg("Finalizing TraceCompiler Run ready\n");
}