#!/usr/bin/perl -w

use strict;

#take two parameters - the locations of the two merged repos

if (!defined($ARGV[0]) || !defined($ARGV[1]))
  {
  print "Usage: $0 repo1 repo2\n";
  print "Where repo1 and repo2 are the locations of the merged repo trees repomanage outputs\n";
  exit 1;
  }

print "||$ARGV[0]|| ||$ARGV[1]||\n";
  
#use repomanage to get a list of the latest packages in each

#my @repo1 = `repomanage $ARGV[0]`;
#my @repo2 = `repomanage $ARGV[1]`;

#output should already be sorted

open (REPO1, $ARGV[0]) || die "Cant open $ARGV[0]";
open (REPO2, $ARGV[1]) || die "Cant open $ARGV[0]";

my @repo1 = (<REPO1>);
my @repo2 = (<REPO2>);


my (%fc_pkg,%fc_version,%fc_release,%fc_arch, %fc_name,%fc_relnum, %fc_relrest);
my (%c_pkg,%c_version, %c_release,%c_arch, %c_name, %c_relnum, %c_relrest);
my ($fc_count, $c_count);
my $repo1_dir="";
my $repo2_dir="";

my $idx = 1;

my $r1 = $repo1[0];
if ($r1 =~ /(.*\/)/)
  {
  $repo1_dir = $1;
  }

foreach ( @repo1 ) {

       #remove the location dir
       
       s/$repo1_dir//;

# read the file list into hashes
      chomp;

#break apart the name and store the values in the hashes      
  
      /(.+)\-(.+)\-(.+)\.(.+)\.rpm$/;
#      print "package $_\n";
#      print "name $1\n";
#      print "version $2\n";
#      print "release $3\n";
#      print "arch $4\n";

      $fc_pkg{$idx} = $_;
      $fc_name{$idx} = $1;
      $fc_version{$idx} = $2;
      $fc_release{$idx} = $3;
      $fc_arch{$idx} = $4;

      ++$idx;
      }

$fc_count = $idx;

$idx=1;

my $r2 = $repo2[0];
if ($r2 =~ /(.*\/)/)
  {
  $repo2_dir = $1;
  }

foreach (@repo2) {

# read the file list into hashes
      chomp;
      
      s/$repo2_dir//;
      
      /(.+)\-(.+)\-(.+)\.(.+)\.rpm$/;

      $c_pkg{$idx} = $_;
      $c_name{$idx} = $1;
      $c_version{$idx} = $2;
      $c_release{$idx} = $3;
      $c_arch{$idx} = $4;

      ++$idx;
      }

$c_count = $idx;

my $pkg;

my $cidx= 1;

for ($idx=1; $idx < $fc_count ; ++$idx )
  {
#  print ("{1 = $fc_name{$idx} 2 = $c_name{$cidx}} ");
  
  if ($fc_name{$idx} le $c_name{$cidx})
    {
    print "||$fc_pkg{$idx}";
    }

  my $cmore = 0;
  
  while ($c_name{$cidx} lt $fc_name{$idx})
      {
#      print ("<fc = $fc_name{$idx} c = $c_name{$cidx}> ");


      # these c ones dont exist in fc

      print "||&nbsp;||&nbsp;||$c_pkg{$cidx}||\n";
      ++$cidx;
      $cmore =1;
      }
      
  if ($cmore)
    {
    --$idx;
    next;
    }
  
  my $match = 0;
  
  if ($c_name{$cidx} eq $fc_name{$idx})
      {
      # both exist 
      if($c_pkg{$cidx} eq $fc_pkg{$idx}) {
        print "||=||";
      }
      else {
        #use rpm2 to compare
      
#        my $fc_ = RPM2->open_package( $repo1_dir.$fc_pkg{$idx} );
#        my $c_ =  RPM2->open_package( $repo2_dir.$c_pkg{$cidx} );
      
        my $result = rpmvercmp($fc_version{$idx}."-".$fc_release{$idx},$c_version{$cidx}."-".$c_release{$cidx} );
        
        if ($fc_version{$idx} eq $c_version{$cidx}) {
            if ($result > 0) {
                print "||&lt;||" 
            }
            elsif ($result < 0) { 
                print "||&gt;||" 
            }
            else { 
                print "||=||" 
            };
        }
        else {
            if ( rpmvercmp($fc_version{$idx},$c_version{$cidx}) > 0 ) {
                print "||&lt;&lt;||"
            }
            else {
            print "||&gt;&gt;||"  
            }
        }
      }
      
      print "$c_pkg{$cidx}||\n";
      ++$cidx;
      $match = 1;
      
    }
  else 
    {
    print "||&nbsp;||&nbsp;";
    }
  
  if(exists($c_name{$cidx+1}))
    {
    if ($c_name{$cidx+1} gt $fc_name{$idx} && !$match && !$cmore)
      {
      print "||\n";
      } 

    }
  }    
#
# parse Red Hat RPM release/version strings into tokens
#
sub rpmverparse {
    my ($ver) = @_;
    
    my @verparts = ();
        
    while ( $ver ne "" ) {
      if ( $ver =~ /^([A-Za-z]+)/ ) {    # leading letters
        push ( @verparts, $1 );
        $ver =~ s/^[A-Za-z]+//;
        }
      elsif ( $ver =~ /^(\d+)/ ) {       # leading digits
        push ( @verparts, $1 );
        $ver =~ s/^\d+//;
        }
      else {                             # remove non-letter, non-digit
        $ver =~ s/^.//;
        }
      }
    }
                                                                       
#
# compare Red Hat RPM release/version strings
#
sub rpmvercmp {
    my ( $a, $b ) = @_;
    my @aparts;                            # list of version/release tokens
    my @bparts;
    my $apart;                             # individual token from array
    my $bpart;
    my $result;

    if ( $a eq $b ) {
        return 0;
    }
    @aparts = rpmverparse($a);
    @bparts = rpmverparse($b);
    while ( @aparts && @bparts ) {
        $apart = shift (@aparts);
        $bpart = shift (@bparts);
        if ( $apart =~ /^\d+$/ && $bpart =~ /^\d+$/ ) {    # numeric
            if ( $result = ( $apart <=> $bpart ) ) {
                return $result;
            }
        }
        elsif ( $apart =~ /^[A-Za-z]+/ && $bpart =~ /^[A-Za-z]+/ ) {    # alpha
            if ( $result = ( $apart cmp $bpart ) ) {
                return $result;
            }
        }
        else {    # "arbitrary" in original code
            return -1;
        }
    }
    if (@aparts) {    # left over stuff in a, assume it's newer
        return 1;
    }
    elsif (@bparts) {    # leftover in b, assume it's newer
        return -1;
    }
    else {               # "should never happen"
        return 0;
    }   
}