#!\bin\perl -w
# Copyright (c) 2003-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:
# CConfig
# 

package CConfig;

use strict;
use IO::File;
use COutputHandler;

# Added for scanlog compatibility
use Time::localtime;

# CConfig New(scalar aFilename) : constructor
sub New($)
	{
	my $proto = shift;
	my ($aFilename) = @_;

	my $class = ref($proto) || $proto;

	my $self = { RELTOOLS_REQUIRED => "",
                     outputHandler => COutputHandler->new()};
	bless($self, $class);
  # undef the logfile here so that the folowing warning goes to stdout
  $self->{iLOGFILE} = undef;
	# Load in options
	if (defined($aFilename))
		{
		if (!$self->Reload($aFilename))
			{
			$self->Warning("Option file could not be loaded.\n");
			}
		}
	
  # Added support for scanlog and Die() control.
  $self->{iPhaseErrorCount} = 0;
	$self->{iPhase} = undef;
        
	return $self;
	}

# boolean Set(scalar aOptionName, scalar aValue)
sub Set($$)
	{
	my $self = shift;
	my ($aOptionName, $aValue) = @_;

	if (!defined($aOptionName))
		{
		$self->Warning("Cannot set undefined option");
		
		return 0;
		}
		
	if (!defined($aValue))
		{
		$self->Warning("Cannot set option '$aOptionName' to undefined value.");
		return 0;
		}
	
	if ((ref($aValue) ne "") && (ref($aValue) ne "ARRAY"))
		{
		$self->Warning("Value of '$aOptionName' must be either a string or list.");
		return 0;
		}

	$self->{iOptions}->{lc($aOptionName)} = [$aOptionName, $aValue];
	return 1;
	}

# scalar Get(scalar aOptionName)
sub Get($)
	{
	my $self = shift;
	my ($aOptionName) = @_;

	if (defined($self->{iOptions}->{lc($aOptionName)}))
		{
		return ($self->{iOptions}->{lc($aOptionName)})->[1];
		}
	else
		{
		return undef;
		}
	}

# boolean Reload(scalar aFilename)
sub Reload($)
	{
	my $self = shift;
	my ($aFilename) = @_;
	my $okay = 1;

	$self->{iOptions}={}; # Blank existing options

	if (!open(FILE, $aFilename))
		{
		$self->Warning("Option file '$aFilename' could not be opened.");
		$okay = 0;
		}
	else
		{
		foreach my $line (<FILE>)
			{
			chomp ($line);

			# Split on colon
			my $parms = $line;
			$parms =~ s/([^\\]):/$1\x08/g; # Turn unescaped colons into 0x08 chars
			$parms =~ s/\\:/:/g; # Unescape escaped colons
			my @parms = split(/\x08/,$parms); # Split on 0x08

			if (scalar(@parms) != 0)
				{
				if (scalar(@parms) == 2)
					{
					my $key = $parms[0];
					$key =~ s/^\s+//; # Remove preceding spaces
					$key =~ s/([^\\])\s$/$1/g; # Remove unescaped trailing spaces
					$key =~ s/\\(\s)/$1/g; # Unescape space characters

					my $value = $parms[1];
					if ($value =~ /\s*\[.*\]\s*$/)
						{
						# Value is a [list]

						# Remove square brackets
						$value =~ s/^\s*\[//;
						$value =~ s/\]\s*$//;

						# Split on comma
						$value =~ s/([^\\]),/$1\x08/g; # Turn unescaped commas into 0x08 chars
						$value =~ s/\\,/,/g; # Unescape escaped commas
						my @values = split(/\x08/,$value); # Split on 0x08

						map(s/^\s+//, @values); # Remove preceding spaces
						map(s/([^\\])\s$/$1/g, @values); # Remove unescaped trailing spaces
						map(s/\\(\s)/$1/g, @values); # Unescape space characters

						$value = [@values];
						}
					else
						{
						# Value is a scalar

						$value =~ s/^\s+//; # Remove preceding spaces
						$value =~ s/([^\\])\s$/$1/g; # Remove unescaped trailing spaces
						$value =~ s/\\(\s)/$1/g; # Unescape space characters
						}

					if (!($self->Set($key, $value)))
						{
						$okay = 0;
						}
					}
				else
					{
					$self->Warning("In file '$aFilename', ".scalar(@parms)." parameters found on a line.\nOnly two parameters, colon separated, are supported.\nLine: '$line'");
					$okay = 0;
					}
				}
			}
		close(FILE);
		}

	return ($okay);
	}

# boolean Save(scalar aFilename)
sub Save($)
	{
	my $self = shift;
	my ($aFilename) = @_;
	my $okay = 1;

	if (!open(FILE, ">$aFilename"))
		{
		$self->Warning("Could not open option file '$aFilename' to save to.");
		$okay = 0;
		}
	else
		{
		foreach my $pair (values(%{$self->{iOptions}}))
			{
			my $key = $pair->[0];
			my $value = $pair->[1];
			
			if (!defined($value))
				{
				$self->Error("Cannot write undefined value for key '$key' when saving options.");
				$okay = 0;
				}
			else
				{

				if (ref($value))
					{
					if (ref($value) ne "ARRAY")
						{
						$self->Error("Cannot write ".ref($value)." for key '$key' when saving options.");
						$okay = 0;
						}
					else
						{
						# It's a list: [value,value,value] and escape any commas or opening spaces
						my @values = @{$value};
						map(s/^(\s)/\\$1/,@values);
						map(s/,/\\,/g,@values);
						$value = "[".join(",",@values)."]";
						}
					}
				else
					{
					# It's a scalar string
					# Escape opening space
					$key =~ s/^(\s)/\\$1/;
					# Escape square brackets;
					}
					
				# Escape colons
				$key =~ s/:/\\:/g;
				$value =~ s/:/\\:/g;
				
				print FILE $key.":".$value."\n";
				}
			}
		close (FILE)
		}
	return $okay;
	}

# boolean SetLog(scalar aFilename)
sub SetLog($)
	{
	my $self = shift;
	my ($aLogFile) = @_;

	if (defined($self->{iLOGFILE}))
		{
		$self->{iLOGFILE}->close();
    # This forces any subsequent error message to go to stdout
    $self->{iLOGFILE} = undef;
		}
	
	if (-e $aLogFile)
		{
		if (-e $aLogFile."~")
			{
			if (!unlink $aLogFile."~")
				{
				$self->Error("Couldn't delete backup log file\n");
				return 0;
				}
			}

		if (system("copy $aLogFile $aLogFile~ > nul 2>&1"))
			{
			$self->Error("Couldn't back-up existing log file\n");
			return 0;
			}
		}
		
	$self->{iLOGFILE}=new IO::File("> $aLogFile");

	if (defined($self->{iLOGFILE}))
		{
		return 1;
		}
	else
		{
		$self->Error("Couldn't open logfile $aLogFile\n");
		return 0;
		}
	}

# void Print(scalar aLogLine)
sub Print($)
	{
	my $self = shift;
	my ($aLogLine) = @_;

	my $logfile = $self->{iLOGFILE};

	if ($aLogLine !~ /\n$/)
		{
		$aLogLine = $aLogLine."\n";
		}
                
        $aLogLine = $self->{outputHandler}->CheckOutput($aLogLine);      

	if (!defined($logfile))
		{
		print $aLogLine;
		}
	else
		{
		print $logfile $aLogLine;
		}
	}

# void Die(scalar aError)
sub Die($)
	{
	my $self = shift;
	my ($aError) = @_;

	my $logfile = $self->{iLOGFILE};

	if ($aError !~ /\n$/)
		{
		$aError = $aError."\n";
		}

	if (!defined($logfile))
		{
		die $aError;
		}
	else
		{
		print $logfile $aError;
		die "ERROR: System experienced a fatal error; check the log file.\n";
		}
	}

# void Status(scalar aMessage)
sub Status($)
	{
	my $self = shift;
	my ($aMessage) = @_;

	if (defined($self->{iLOGFILE}))
		{
		print STDOUT $aMessage."\n"; # Only display status (to STDOUT) if everything else is going to the logfile
		}
	}

# Returns the number of errors encountered in a phase
sub GetErrorCount()
  {
  my $self = shift;
  return $self->{iPhaseErrorCount};
  }

###########################################
# Utility functions
###########################################

# boolean CheckRelTools()

sub CheckRelTools()
	{
	# Search for reldata API
	my $found = 0;
	foreach my $path (split(/;/,$ENV{PATH}))
		{
		if (-e $path."\\reldata\.pm")
			{
			$found = 1;
			last;
			}
		}
	
	return $found
	}

# void RequireRelTools() - Requires RelData and IniData. Dies if tools can't be located, or die when being required.

sub RequireRelTools()
	{
	my $self = shift;

	if ($self->{RELTOOLS_REQUIRED} ne "required")
		{
		# Locate reldata API
		my $found = 0;
		foreach my $path (split(/;/,$ENV{PATH}))
			{
			if (-e $path."\\reldata\.pm")
				{
				push @INC, $path;
				$found = 1;
				last;
				}
			}

		if (!$found)
			{
			$self->Error("Couldn't find release tools in path");
			}

		# Require core modules
		require RelData;
		require IniData;
		$self->{RELTOOLS_REQUIRED}="required";
		}
	}

###########################################
# Handling Commands, Phases and components.
###########################################

# void Command(scalar aMessage)
# Prints out a command in scanlog format to the log file or stdout
sub Command($)
  {
  my $self = shift;
	my ($aCommand) = @_;
  my $message = "===-------------------------------------------------\n=== Stage=$self->{stageNumber}.$aCommand\n===-------------------------------------------------\n";	my $logfile = $self->{iLOGFILE};
  $self->Print($message);
	}

# void PhaseStart(scalar aPhaseName)
# If a current phase is active then this is closed, if when doing so a
# non-zero error count is returned by PhaseEnd() then Die is called. This
# is regarded as a logic error as the stage runner should normally call PhaseEnd()
# itself and decide what to do about any errors that occured in that phase.
sub PhaseStart($)
  {
  my $self = shift;
  my $phase = shift;
  if (defined $self->{iPhase})
    {
    my $numErrs = $self->PhaseEnd();
    # If there are errors returned by PhaseEnd then Die()
    if ($numErrs != 0)
      {
        $self->Die("Fatal logic error detected, CConfig::PhaseStart() called without PhaseEnd() when phase has $numErrs errors.\n");
      }
    }
    
    $self->{stageNumber}++; # For scanlog compatibility
    
    
    $self->Command($phase);
    $self->{iPhase} = $phase;

    my $localTime = ctime(); 
    my $message = "=== Stage=$self->{stageNumber}.$self->{iPhase} started $localTime\n";
    $message .= "=== Stage=$self->{stageNumber}.$self->{iPhase} == $self->{iPhase}\n"; # For Scanlog compatibility
    $message .= "+++ HiRes Start " . time() . "\n"; # For Scanlog compatibility
    $message .= "--  $self->{iPhase}: Miscellaneous\n"; # For Scanlog compatibility
    $self->Print($message);
    $self->{iPhaseErrorCount} = 0;
  }
  
# scalar PhaseEnd(void)
# Closes the current phase and returns a count of the number of errors encountered.
# This will die if a PhaseStart() has not been declared.
sub PhaseEnd()
  {
  my $self = shift;
  my $localTime = ctime();
  if (defined $self->{iPhase})
    {   
    my $message = "+++ HiRes End " . time() . "\n"; # For Scanlog compatibility
    $message .= "=== Stage=$self->{stageNumber}.$self->{iPhase} finished $localTime\n";
    $self->Print($message);
    }
  else
    {
    $self->Die("Error: CConfig::PhaseEnd() called without corresponding PhaseStart()\n");
    }
	$self->{iPhase} = undef;
  return $self->{iPhaseErrorCount};
  }
  
# void Component(scalar aComponent)
# Prints out a component for this phase in scanlog format to the log file or stdout
sub Component($)
  {
  my $self = shift;
	my ($aComponent) = @_;
  if (!defined $self->{iPhase})
    {
    $self->Die("Logger: Undefined phase for component \"$aComponent\"\n");
    }
  else
    {
    my $message = "+++ HiRes End " . time() . "\n-- $aComponent\n+++ HiRes Start " . time();
    $self->Print($message);
    }
  }

###############################
# Handling errors and warnings.
###############################

# void Error(scalar aMessage)
# Writes an error message to the logfile (if defined) or stdout
# and will increment the error count for this phase.
sub Error($)
  {
	my $self = shift;
	my ($aMessage) = @_;
  $self->{iPhaseErrorCount} += 1;
  my $message = "ERROR: $aMessage";
  $self->Print($message);
  }

# void Warning(scalar aMessage)
# Writes an warning message to the logfile (if defined) or stdout
sub Warning($)
  {
	my $self = shift;
	my ($aMessage) = @_;
  my $message = "WARNING: $aMessage";
  $self->Print($message);
  }

sub DESTROY
	{
	my $self = shift;

	# Avoid "unreferenced scalar" error in Perl 5.6 by not calling
	# PhaseEnd method for each object in multi-threaded CDelta.pm

   if ((defined $self->{iPhase}) && ($self->{iPhase} !~ /CDelta/)) {
      $self->PhaseEnd;
   }

	if (defined($self->{iLOGFILE}))
		{
		$self->{iLOGFILE}->close();
		$self->{iLOGFILE} = undef;
		}
	}
1;