:
# Runs Perl scripts via sh on all Progress platforms including NT/MKS.
eval '\
    if [ -f /tools/etc/setmach ]; then\
  . /tools/etc/setmach;\
    fi;\
    if [ -z "$PROCESSOR_LEVEL" ]; then\
  exec /tools/$MACHINE/perl-5.6.1/bin/perl $perldebug -S $0 ${1+"$@"};\
    else\
  export SHELL=$ROOTDIR/mksnt/sh.exe;\
  perl $perldebug -S $0 ${1+"$@"};\
  exit $?;\
    fi'
if 0;
################################################################################

$| = 1;

use strict;
use Cwd 'abs_path';
use lib '/scratch/rsiddapp/perl_modules/Carp-Clan-6.04/lib';
use lib '/scratch/rsiddapp/perl_modules/Date-Calc/lib';
use Date::Calc qw(:all);

use Getopt::Long;
use Pod::Usage;

my @ERRORS;
my %OPTION;
print " + DEBUG : Calling ParseCommandLineOptions\n";
ParseCommandLineOptions(@_);

sub SystemCmd(@_)
{
    my @cmd = @_;
    my $pwd = `pwd`;
    if (system(@_)) {
        LogErrorAndExit("system cmd @_ failed in $pwd");
    }

}
sub LogErrorAndExit(@_)
{
    print "ERROR: @_\n";
    exit 1;
}

        #print "\nPlease Enter For which OSTORE version you want the build time, E.g. 7.4.0 \n";
        my $ver;
#-------------------------------------------------------------------------------
# Parse command line arguments and fill up 'OPTIONS' hash
#-------------------------------------------------------------------------------
sub ParseCommandLineOptions()
{

        print " + DEBUG : Getting the Options\n";
    GetOptions(\%OPTION,
               'all',
               'win',
               'unix');


        foreach my $pKey ( sort keys %OPTION ) {

                print " ++ DEBUG : *$pKey* \n";
        }

        if ( $OPTION{all}) {


    if ($OPTION{unix}) {
        print "\nPlease Enter For which OSTORE version you want the build time, E.g. 7.4.0 \n";
        $ver = <STDIN>; chomp($ver);
        my $path = "/odi/ostore_platform_logs/ostore/$ver/test1";
        chdir($path);
opendir (LOC, "/odi/ostore_platform_logs/ostore/ver/test1") || die "can't opendir $!\n";

        my @list = readdir(LOC);

        foreach my $d (@list)
        {

    next if ( $d =~ /^(\.+|all$)/ );

        chomp($d);
        if ($d =~ /^winnt/) { next; }

        push (my @plat,$d);
                print "\nPlatform Name:: $d";
                foreach my $p (@plat)
                {
                   $p =~ s/\.$//;
                   chomp($p);

my $npath = '/odi/ostore_platform_logs/ostore/7.4.0/test1';
   $npath = $npath.'/'. $p;
   chdir($npath);
   #print "\n$npath";
my $LATEST = `ls -tr | tail -1`;
   chomp $LATEST;
                        print "\n################################\n";
            my $pFile = $path .'/'. $p .'/'. $LATEST . '/'. 'build_os.log';

open ( FH, "<$pFile") || die " = ERROR : Problem reading the file : $pFile : $!\n";

                        my $ghModule;
                        my $pOpen = 0;
                        my $pStart = '';
                        my $pEnd   = '';
                        my $pModule = '';

                        while ( my $pLine = <FH> ) {

                        chomp $pLine;

                        # Ignore lines of the below format
                        # Starting stop OSCI tslaunch in ostore_7.4_int_bld.sol2c5.picopt at 2011-09-10-1738

                        next if ( $pLine =~ /^\s*Starting\s+stop\s+/ );

                        if ( ( $pOpen ) && ( $pLine =~ /\s*:\s*Completed\s+/ ) ) {

                        $pEnd = $pLine;
                        $pEnd =~ s/.*\s+at\s+//;
                        $pEnd =~ s/\.$//;

                        $ghModule->{$pModule}{START} = $pStart;
                        $ghModule->{$pModule}{END}   = $pEnd;
                        $pOpen = 0;
                        $pEnd = '';
                        $pStart = '';
                        }

                        if ( $pLine =~ /^\s*Starting.*\s+at\s+/ ) {

                        next if ( $pLine =~ /^\s*Starting\s+javac\s+/ );

                        $pOpen = 1;
                        $pModule = $pLine;
                        $pModule =~ s/^\s*Starting//i;
                        $pModule =~ s/\s+at.*$//i;

                        # Starting osci cdimage in ostore_7.4_int_bld.sol2c5.picopt at 2011-09-08-1725.
                        $pStart = $pLine;
                        $pStart =~ s/.*\s+at\s+//;
                        $pStart =~ s/\.$//;

                        }
                }

                close FH;

                foreach my $pModule ( sort keys %{$ghModule} ) {

                        my $pTime = &getDifference($ghModule->{$pModule}{START}, $ghModule->{$pModule}{END} );

                        print " + $pModule .. $ghModule->{$pModule}{START} .. $ghModule->{$pModule}{END} .. $pTime\n";
                }

#
sub getDifference {

  my $pTime1 = shift || '';
  my $pTime2 = shift || '';

  my $pTimeConv1 = &getRelativeTime($pTime1);

  my $pTimeConv2 = &getRelativeTime($pTime2);

  #my $pTimeDiff = $pTimeConv2 - $pTimeConv1;
  ################################################
  my $pTimeDiff = ($pTimeConv2 - $pTimeConv1)/60;
  return "$pTimeDiff minutes";
  ################################################
  #return "$pTimeDiff seconds";
}

sub getRelativeTime {

  my $pValue = shift || '';

  $pValue =~ /(\d+)-(\d{2})-(\d{2})-(\d{4})/;

  my $pYear = $1;
  my $pMonth= $2;
  my $pDay  = $3;
  my $pTime = $4;

  $pTime =~ /(\d{2})(\d{2})/;

  my $pHour = $1;
  my $pMin  = $2;

  # Leap
  my $pLeapYear = 0;
  $pLeapYear = 1 if ( $pYear%4 == 0 );

  my $pYearConv = &getElapsedYear($pYear);

  my $pMonthConv = &getElapsedMonth($pMonth, $pLeapYear);

  my $pDayConv   = $pDay*24*60*60;

  my $pHourConv = $pHour * 60 * 60 ;

  my $pMinConv  = $pMin * 60;

  my $pTotalConv = $pYearConv + $pMonthConv + $pDayConv + $pHourConv + $pMinConv;

  return $pTotalConv;
}

sub getElapsedMonth {

  #
  my $pMonth = shift || '';
  my $pLeapYear = shift || 0;

  my $pTime = 0;

  $pMonth =~ s/^0//;

  while ( $pMonth >= 1 ) {

    if ( $pMonth =~ /1|3|5|7|8|10|12/ ) {

      $pTime += 31*24*60*60;
    }
    elsif ( $pMonth =~ /4|6|9|11/ ) {

      $pTime += 30*24*60*60;
    }
   elsif ( $pMonth eq '2' ) {

     if ($pLeapYear) {

       $pTime += 29*24*60*60;
     }
     else {

       $pTime += 28*24*60*60;
     }
   }

   $pMonth--;
  }

  return $pTime;
}

sub getElapsedYear {

  my $pYear = shift || '';

  my $stYear = 2010;

  #
  my $pTime = 0;

  while ( $pYear > $stYear ) {

    if ( $pYear%4 == 0 ) {

      $pTime += 366*24*60*60;
    }
    else {

      $pTime += 365*24*60*60;
    }

    $pYear--;
  }

  return $pTime;
}
        print "\n################################\n";
                }
        }

}

        if ( $OPTION{win} ) {

print " ++DEBUG :: In the Windows Routine\n";
                my $bm_file='/scratch/rsiddapp/diva_script/build_modules';
                my @build_module=();
                my @start_check_module=();
                my @finish_check_module=();
                my $wm_file='/scratch/rsiddapp/diva_script/windows_machines';
                my @windows_machines=();
                my ($sdate,$time,$fdate,$ftime)="";
                my $log_path="/odi/ostore_platform_logs/ostore/$ver/test1";
                my $log_file='osi_nt_driver.log';
                my $sdate; my $stime; my $fdate; my $ftime;

                read_build_module_input();
                read_windows_machine_input();
                get_start_finish_time();

                sub read_build_module_input
                {
                        open(BM,"$bm_file") || die "Couldn't open the file $bm_file $!\n";
                        while (my $bm_inp=<BM>)
                        {
                                chomp($bm_inp);
                                push(@build_module,$bm_inp);
                        }
                        close(BM);
                }

                sub read_windows_machine_input
                {
                        open(WM,"$wm_file") || die "Couldn't open the file $wm_file $!\n";
                        while(my $wm_inp=<WM>)
                        {
                                chomp($wm_inp);
                                push(@windows_machines,$wm_inp);
                        }
                        close(WM);
                }

                sub get_start_finish_time
                {
                        foreach my $mac (@windows_machines)
                                {print "\n\n***************$mac******************\n";
                                        foreach my $mod (@build_module)
                                                {print "\nMODULE: $mod\n";
                                                        my $dir=`ls -tr ${log_path}/${mac} | tail -1`;
                                                        chomp($dir);
                                                        open(LF,"${log_path}/${mac}/${dir}/${log_file}") || die "Couldn't open the file $log_file $! \n";
                                                        while (my $line=<LF>)
                                                        {
                                                                chomp($line);
                                                                if ($line =~ /Started\s+$mod/ || $line =~ /Finished\s+$mod/)
                                                                {
                                                                        if ($line =~ /Started/)
                                                                        {
                                                                                if (!grep(/$mod/,@start_check_module))
                                                                                {
                                                                                        push(@start_check_module,$line);

                                                                                        $line =~ s/\*//g;
                                                                                        (my $sdate, my $stime)=split (/\s+/,$line);
                                                                                }
                                                                        }
                                                                        if ($line =~ /Finished/)
                                                                        {
                                                                                if (!grep(/$mod/,@finish_check_module))
                                                                                {
                                                                                        $line =~ s/\*//g;
                                                                                        (my $fdate,my $ftime)=split(/\s+/,$line);
                                                                                }

                                                                        }
                                                                }
                                                        }
                                                        close(LF);@start_check_module=@finish_check_module=();

                                                        if ($sdate && $stime && $fdate && $ftime)
                                                        {
                                                        time_diff($sdate,$stime,$fdate,$ftime);
                                                        $sdate=$stime=$fdate=$ftime="";
                                                        }
                                                        else
                                                        {
                                                        next;
                                                        }

                                                }print "\n**************End of $mac**********\n";
                                        }
                }

                sub time_diff()
                {
                        my ($tsdate,$tstime,$tfdate,$tftime)=@_;
                        my ($tsyear,$tsmon,$tsday)=split(/-/,$tsdate);
                        my ($tshh,$tsmm,$tsss)=split(/:/,$tstime);
                        my ($tfyear,$tfmon,$tfday)=split(/-/,$tfdate);
                        my ($tfhh,$tfmm,$tfss)=split(/:/,$tftime);
                        my ($tot_day,$tot_hh,$tot_mm,$tot_ss)=Delta_DHMS($tsyear,$tsmon,$tsday,$tshh,$tsmm,$tsss,$tfyear,$tfmon,$tfday,$tfhh,$tfmm,$tfss);
                        my $total_hour=24*$tot_day+$tot_hh;

                        print "Run Start Date: $tsdate\t Run Start Time: $tstime\n";
                        print "Run End Date: $tfdate\t Run End Time: $tftime\n";
                        print "Total Time Taken: $total_hour:$tot_mm:$tot_ss \n";
                }
        }
  }
}