#!/usr/bin/perl

use strict;
use warnings;
use Getopt::Long;

my $mockcfg = "fedora-devel-x86_64";
my $passt = "YES";
my $failt = "NO";
my $notestt = "?";

my $br = 0;
my $of = 0;
my $postld = 0;
my $postunld = 0;
my $hasstatic = 0;
my $hasheaders = 0;
my $haspc = 0;
my $hasdevel = 0;
my $hasso = 0;
my $pkgname = "";
my $headerst = "Header files are in -devel (-debuginfo) package.";
my $statict = "Static libraries are in -static package";
my $pkgconfigt = "pkgconfig -> Requires: pkgconfig is used.";
my $libst = "No versioned libraries in -devel package.";
my $devel_requiret = "-devel requires the base package using a fully versioned dependency.";
my $ldconfigt = "ldconfig is called in %post and %postun.";
my $pct = ".pc files are in -devel.";

my $rermrf = qr/^\s*(%{?__)?rm}?\s+((-r-?f)|(-f-?r))\s+((%\{?buildroot\}?)|(\$\{?RPM_BUILD_ROOT\}?))\b/;
my $help = 0;
my $nokoji = 0;
my $nobuild = 0;
my $specname = "";
my $targetdir = "";
my $rpmname = "";

my $rpmlint_out = "";
my $utf8_out = "";
my $rpmlint_silent = "$failt";
my $macros_const = "$failt";
my $pkgname_match = "$failt";
my $sources_match = "$failt";
my $utf8 = "$failt";
my $clean = "$failt";
my $install = "$failt";
my $ldconfig;
my $scratch_build = "$failt";
my $mock_build = "$failt";
my $nolibtool = "$notestt";
my $man = "$failt";
my $headers = "$passt";
my $static = "$passt";
my $pc = "$passt";
my $pkgconfig = "$failt";
my $devel_require = "$failt";
my $libs = "$passt";

my @files;
my @lines;

sub help
{
  local $\ = "\n";
  print("This script helps you with Fedora merge review.\n");
  print("Usage: " . $0 . " [OPTIONS] [SPECFILE]\n");
  print("If no SPECFILE is specifed the last found in the current dir is taken.\n");
  print("OPTIONS:\n");
  print("    --nokoji      No Koji build is done.");
  print("    --nobuild     No Koji and no Mock build is done.");
  print("    --help        Displays this help.\n");
}

GetOptions("help" => \$help, "nokoji" => \$nokoji, "nobuild" => \$nobuild);

if ($help)
{
  help();
  exit();
}
if ($#ARGV == -1)
{
  opendir(DIR, ".");
  @files = grep(/\.spec$/, readdir(DIR));
  closedir(DIR);
  if ($#files >= 0)
  {
    $specname = $files[$#files];
  }
  else
  {
    die("ERROR: No SPECFILE found.\n");
  }
}
else
{
  if ($#ARGV == 0)
  {
    $specname = $ARGV[0];
  }
  else
  {
    help();
    exit(1);
  }
}

open(F1, "<" . $specname) || die("ERROR: Unable to open file '$specname'.\n");

while (<F1>)
{
  if (/^\s*Name:\s+(\S+)/)
  {
    $pkgname = "$1";
  }
  if (/%{?buildroot}?/)
  {
    $br |= 1;
  }
  if (/\${?RPM_BUILD_ROOT}?/)
  {
    $br |= 2;
  }
  if (/\%{?optflags}?/)
  {
    $of |= 1;
  }
  if (/\${?RPM_OPT_FLAGS}?/)
  {
    $of |= 2;
  }
  if (/^\s*%clean\b/)
  {
    while (defined($_ = <F1>) && /^\s*$/) {}
    if (/$rermrf/)
    {
      $clean = "$passt";
    }
  }
  if (/^\s*%install\b/)
  {
    while (defined($_ = <F1>) && /^\s*$/) {}
    if (/$rermrf/)
    {
      $install = "$passt";
    }
  }
  if (/^\s*%post\b/)
  {
    if (/\bldconfig\b/)
    {
      $postld = 1;
    }
    else
    {
      while (defined($_ = <F1>) && /^\s*((\w+)|$)/)
      {
        if (/\bldconfig\b/)
        {
          $postld = 1;
        }
      }
      redo if defined($_);
    }
  }
  if (/^\s*%postun\b/)
  {
    if (/\bldconfig\b/)
    {
      $postunld = 1;
    }
    else
    {
      while (defined($_ = <F1>) && /^\s*((\w+)|$)/)
      {
        if (/\bldconfig\b/)
        {
          $postunld = 1;
        }
      }
      redo if defined($_);
    }
  }
  if (/^\s*%package\s+.+-devel\b/)
  {
    $hasdevel = 1;
    while (defined($_ = <F1>) && /^\s*((\w+)|$)/)
    {
      if (/^\s*Requires:\s+%{?name}?\s*=\s*%{?version}?-%{?release}?\b/)
      {
        $devel_require = "$passt";
      }
      if (/^\s*Requires:\s+pkgconfig\b/)
      {
        $pkgconfig = "$passt";
      }
    }
    redo if defined($_);
  }
}

close(F1);

if ( $br != 3 && $of != 3)
{
  $macros_const = "$passt";
}


my $specbase = $specname;
$specbase =~ s/^(.*)\.[^\.]+$/$1/;

#pgkname match
if ($pkgname eq $specbase)
{
  $pkgname_match = "$passt";
}

#sources match
`make sources &>/dev/null`;
`md5sum -c sources &> /dev/null`;
if (($? >> 8) == 0)
{
  $sources_match = "$passt";
}

#is UTF8
$utf8_out = "\n" . `isutf8 $specname`;
if (($? >> 8) == 0)
{
  $utf8 = "$passt";
  $utf8_out = "\n";
}

#scratch-build
if ($nokoji || $nobuild)
{
  $scratch_build = "$notestt";
}
else
{
  `PYTHONUNBUFFERED=1 fedpkg scratch-build &> scratch-build.log`;
  if (($? >> 8) == 0)
  {
    $scratch_build = "$passt";
  }
}

#mock-build
if ($nobuild)
{
  $mock_build = "$notestt";
}
else
{
  `PYTHONUNBUFFERED=1 MOCKCFG=$mockcfg fedpkg mockbuild &> mock-build.log`;
  if (($? >> 8) == 0)
  {
    $mock_build = "$passt";
  }
}


#locate target dir with builds
if (open(F1, "<mock-build.log"))
{
  @lines = grep(/\s+--resultdir=/, readline(*F1));
  if ($#lines >= 0)
  {
    $targetdir = $lines[$#lines];
    $targetdir =~ s/^.*--resultdir=(\S+)\s.*$/$1/;
    $targetdir =~ s/.*\/(\S+)\s*$/$1/;
  }
  close(F1);

#scan all rpms
  if ($targetdir ne "" &&  opendir(DIR, "$targetdir"))
  {
    @files = grep(/\.rpm$/, readdir(DIR));
    closedir(DIR);
    $nolibtool = "$passt";
    foreach (@files)
    {
      $rpmname = "$_";
      if (open(F1, '-|', "rpmls \"$targetdir/$_\""))
      {
        while (<F1>)
        {
#check .la files
          if (/\.la$/)
          {
            $nolibtool = "$failt";
          }
#check man pages
          if (/.*\/man\/.*\.(\d)+p?m?(.gz)?$/ && $rpmname !~ /((-devel-)|(-static-)|(-doc-))/)
          {
            $man = "$passt";
          }
#check headers
          if (/\.h$/)
          {
            $hasheaders = 1;
            if ($rpmname !~ /((-devel-)|(-debuginfo-))/)
            {
              $headers = "$failt";
            }
          }
#check static
          if (/\.a$/)
          {
            $hasstatic = 1;
            if ($rpmname !~ /-static-/)
            {
              $static = "$failt";
            }
          }
#check .pc
          if (/\.pc$/)
          {
            $haspc = 1;
            if ($rpmname !~ /-devel-/)
            {
              $pc = "$failt";
            }
          }
#check .so
          if (/\.so(\.[\.\d]+)?$/)
          {
            $hasso = 1;
            if (/\.so.[\.\d]+$/ && $rpmname =~ /-devel-/)
            {
              $libs = "$failt";
            }
          }
        }
      }
    }
  }
}

#rpmlint
my $line;
my $cmd = "rpmlint $specname";

if ($targetdir ne "")
{
  $cmd .= " $targetdir/*.rpm";
}

open(F1, '-|', "$cmd") || die "rpmlint failed";

while (<F1>)
{
  $line = $_;
  $rpmlint_out .= $line;
}

close(F1);

my $rlerrors = $line;
$rlerrors =~ s/^.*\D(\d+) errors.*$/$1/;
my $rlwarnings = $line;
$rlwarnings =~ s/^.*\D(\d+) warnings.*$/$1/;

if ($rlerrors == 0 && $rlwarnings == 0)
{
  $rpmlint_silent = "$passt";
  $rpmlint_out = "";
}
else
{
  $rpmlint_out = "\n" . $rpmlint_out;
}

if ($hasheaders)
{
  $headerst = "\n[$headers] $headerst";
}
else
{
  $headerst = "";
}

if ($hasstatic)
{
  $statict = "\n[$static] $statict";
}
else
{
  $statict = "";
}

if ($haspc)
{
  $pct = "\n[$pc] $pct";
  $pkgconfigt = "\n[$pkgconfig] $pkgconfigt";
}
else
{
  $pct = "";
  $pkgconfigt = "";
}

if ($hasdevel)
{
  $devel_requiret = "\n[$devel_require] $devel_requiret";
  $libst = "\n[$libs] $libst";
}
else
{
  $devel_requiret = "";
  $libst = "";
}

#ldconfig
if ($hasso)
{
  if ($postld && $postunld)
  {
    $ldconfigt = "\n[$passt] $ldconfigt";
  }
  else
  {
    $ldconfigt = "\n[$failt] $ldconfigt";
  }
}
else
{
  $ldconfigt = "";
}

print <<END;
MUST items:
[$rpmlint_silent] rpmplint is silent$rpmlint_out
[?] Package meets naming guidelines.
[?] Package meets packaging guidelines.
[$pkgname_match] Spec file matches base package name.
[?] License file is present, matching with spec file.
[?] Licensing Guidelines are met.
[?] Spec file is legible and in American English.
[$sources_match] Sources match upstream.
[$scratch_build] Package builds OK.
[?] BuildRequires is correct.$ldconfigt
[?] Package doesn't bundle copies of system libraries.
[?] Package owns all the directories it creates.
[?] Package has no duplicity in %files.
[?] Permission on files are set properly.
[?] Package has correctly installed .desktop file.
[$clean] %clean section is correct.
[$macros_const] Spec file has consistant macro usage.
[?] Package is code or permissable content.
[?] %doc files don't affect runtime.$headerst$statict$pkgconfigt$devel_requiret$libst
[$nolibtool] No .la libtool archives.
[?] Package doesn't own files/directories that other packages own.
[$install] Package has rm -rf \$RPM_BUILD_ROOT at beginning of %install.
[$utf8] Spec file is valid UTF-8.$utf8_out
Should items:
[$mock_build] Package builds in mock.
[?] Package uses sane scriptlets.
[$man] Package contains man pages.$pct
END
#'