#! /usr/bin/env perl

use Cwd;
use File::Basename;
use File::Spec;
use Getopt::Long qw(:config bundling no_ignore_case);
use IO::Handle;
use POSIX;

use strict;
use warnings;

my $help = 0;
my $build_binary = 1;
my $batch = 0;
my $builddir;
my $build_number;
GetOptions ("h|help" => \$help,
	    "binary!" => \$build_binary,
	    "batch!" => \$batch,
	    "o|output=s" => \$builddir,
	    "build-number=i" => \$build_number);

usage () if $help;

die "$0: exactly one or two nonoption arguments are required\n"
  if @ARGV != 1 && @ARGV != 2;

my $tarball;
if (@ARGV == 1) {
    $tarball = File::Spec->rel2abs ($ARGV[0]);
} else {
    # Tarball will be generated later.
}

# Select build number.
if (!defined ($build_number)) {
    $build_number = POSIX::strftime("%Y%m%d%H%M%S", localtime);
}

my $topdir = dirname ($0);
$topdir = cwd () . "/$topdir" if $topdir !~ m%^/%;

# Create build directory.
if (!defined ($builddir)) {
    $builddir = "builds/$build_number";
    mkdir "builds" or die "builds: mkdir: $!\n" if ! -d "builds";
}
$builddir = File::Spec->rel2abs ($builddir);
-d $builddir or mkdir $builddir or die "$builddir: mkdir: $!\n";
chdir ($builddir) or die "$builddir: chdir: $!\n";

our $resultsdir = "$builddir/results";
mkdir $resultsdir or die "$resultsdir: mkdir: $!\n";
mkdir "$resultsdir/vars" or die "$resultsdir/vars: mkdir: $!\n";

my $varsfile = "$resultsdir/VARS";
open (VARS, '>', $varsfile) or die "creating $varsfile failed: $!\n";
VARS->autoflush (1);

our $logfile = "$resultsdir/LOG";
open (LOG, '>', $logfile) or die "creating $logfile failed: $!\n";

my $build_host = `hostname`;
chomp $build_host;
set_var ("build_host", $build_host);
set_var ("build_number", $build_number);

our $GIT = "git --git-dir=$topdir/.git";

sub start_step {
    my ($msg) = @_;
    print LOG "\n$msg\n";
    print "$msg\n" unless $batch;
}

sub set_var {
    my ($var, $value) = @_;

    print VARS "$var=$value\n";

    print "\t$var=$value\n" unless $batch;

    open (VAR, '>', "$resultsdir/vars/$var")
      or die "creating $resultsdir/$var failed: $!\n";
    print VAR "$value\n";
    close VAR;
}

sub saved_result {
    my ($name, $product) = @_;
    start_step ("Saving $name: $product");
}

sub save_result {
    my ($name, $src, $rm_src) = @_;
    my ($basename) = $src;
    $basename =~ s(^.*/)();
    my ($dst) = "$resultsdir/$basename";

    saved_result ($name, $basename);
    run ("cp -R $src $dst");

    if (defined ($rm_src) && $rm_src) {
	run ("rm $src");
    }

    return $dst;
}

sub save_result_if_exists {
    my ($name, $src, $rm_src) = @_;
    if (-e $src) {
	save_result (@_);
    } else {
	start_step ("$src does not exist, cannot save");
    }
}

sub ref_to_commit {
    my ($ref) = @_;
    my $commit = `$GIT rev-parse $ref`;
    chomp $commit;
    return $commit;
}

if (@ARGV == 2) {
    my ($repo, $branch) = @ARGV;

    start_step ("Fetch branch from Git");
    set_var ("git_repo", $repo);
    set_var ("git_branch", $branch);
    run ("$GIT fetch $repo +$branch:refs/builds/$build_number/pspp");

    # Get revision number.
    set_var ("pspp_ref", "refs/builds/$build_number/pspp");
    my $revision = ref_to_commit ("refs/builds/$build_number/pspp");
    set_var ("pspp_commit", $revision);
    my $abbrev_commit = substr ($revision, 0, 6);

    # Extract source.
    start_step ("Extract branch into source directory");
    run ("$GIT archive --format=tar --prefix=pspp/ refs/builds/$build_number/pspp | tar xf -");

    # Extract version number.
    start_step ("Extract repository version number");
    my $trace = `cd pspp && autoconf -t AC_INIT`;
    chomp $trace;
    my ($file, $line, $macro, $package, $repo_version, @rest)
      = split (':', $trace);
    set_var ("repo_version", $repo_version);

    # Is this a "gnits" mode tree?
    start_step ("Checking Automake mode");
    open (MAKEFILE_AM, '<', "pspp/Makefile.am");
    my $am_mode = "gnu";
    while (<MAKEFILE_AM>) {
	if (/gnits/) {
	    $am_mode = "gnits";
	    last;
	}
    }
    close (MAKEFILE_AM);
    print LOG "Automake mode is $am_mode\n";

    # Generate version number for build.
    # We want to append -g012345, but if we're in Gnits mode and the
    # version number already has a hyphen, we have to omit it.
    start_step ("Generate build version number");
    my $version = $repo_version;
    $version .= '-' unless $version =~ /-/;
    $version .= "g$abbrev_commit";
    set_var ("version", $version);

    # Append -g012345 to configure.ac version number.
    start_step ("Updating version number in $file");
    my $fullname = "pspp/$file";
    open (OLDFILE, '<', $fullname)
      or die "opening $fullname failed: $!\n";
    open (NEWFILE, '>', "$fullname.new")
      or die "creating $fullname.new failed: $!\n";
    while (<OLDFILE>) {
	if ($. != $line) {
	    print NEWFILE $_;
	} else {
	    print NEWFILE "AC_INIT([$package], [$version]";
	    print NEWFILE ", [$_]" foreach @rest;
	    print NEWFILE ")\n";
	}
    }
    close (NEWFILE);
    close (OLDFILE);
    rename ("$fullname.new", $fullname)
      or die "rename $fullname.new to $fullname failed: $!\n";

    # Get Gnulib commit number.
    start_step ("Reading README.Git to find Gnulib commit number");
    my $gnulib_commit;
    $fullname = "pspp/README.Git";
    open (README_GIT, '<', $fullname)
      or die "opening $fullname failed: $!\n";
    while (<README_GIT>) {
	($gnulib_commit) = /^\s+commit ([0-9a-fA-F]{8,})/ and last;
    }
    die "$fullname does not specify a Git commit number\n"
      if !defined ($gnulib_commit);
    set_var ("gnulib_commit", $gnulib_commit);

    # Add note to beginning of NEWS (otherwise "make dist" fails).
    start_step ("Updating NEWS");
    $fullname = "pspp/NEWS";
    open (OLDFILE, '<', $fullname)
      or die "opening $fullname failed: $!\n";
    open (NEWFILE, '>', "$fullname.new")
      or die "creating $fullname.new failed: $!\n";
    my $found_changes = 0;
    while (<OLDFILE>) {
	if (!$found_changes && /^Changes/) {
	    $found_changes = 1;
	    print NEWFILE <<EOF;
Changes from $repo_version to $version:

 * Built from PSPP commit $revision
   in branch $branch on host $build_host.

 * Built from Gnulib commit $gnulib_commit.

EOF
	}
	print NEWFILE $_;
    }
    close (NEWFILE);
    close (OLDFILE);
    rename ("$fullname.new", $fullname)
      or die "rename $fullname.new to $fullname failed: $!\n";

    # If we don't already have that Gnulib commit, update Gnulib.
    system ("$GIT rev-parse --verify --quiet $gnulib_commit^0 > /dev/null");
    if ($? != 0) {
	start_step ("Updating Gnulib to obtain commit");
	run ("$GIT fetch gnulib");
    }
    run ("$GIT update-ref refs/builds/$build_number/gnulib $gnulib_commit");
    set_var ("gnulib_ref", "refs/builds/$build_number/gnulib");

    # Extract gnulib source.
    start_step ("Extract Gnulib source");
    run ("$GIT archive --format=tar --prefix=gnulib/ $gnulib_commit | tar xf -");

    # Bootstrap.
    start_step ("Bootstrap (make -f Smake)");
    run ("cd pspp && make -f Smake", "bootstrap");

    # Configure.
    start_step ("Configure source");
    run ("cd pspp && mkdir _build && cd _build && ../configure", "configure");

    # Distribute.
    start_step ("Make source tarball");
    run ("cd pspp/_build && make dist", "dist");
    my $tarname = "pspp-$version.tar.gz";
    $tarball = save_result ("source distribution", "pspp/_build/$tarname", 1);

    # Save translation templates.
    my $potfile = "pspp/_build/po/pspp.pot";
    $potfile = "pspp/po/pspp.pot" if ! -e $potfile;
    save_result ("translation templates", $potfile);

    # Build user manual
    start_step ("Build user manual");
    run ("cd pspp && cp _build/doc/*.texi doc/");
    run ("cd pspp && GENDOCS_TEMPLATE_DIR=$topdir $topdir/gendocs.sh -s doc/pspp.texinfo -o $resultsdir/user-manual --email bug-gnu-pspp\@gnu.org pspp \"GNU PSPP User Manual\"", "user-manual");
    saved_result ("User Manual", "user-manual");

    # Build developer's guide
    start_step ("Build developers guide");
    run ("cd pspp && GENDOCS_TEMPLATE_DIR=$topdir $topdir/gendocs.sh -s doc/pspp-dev.texinfo -o $resultsdir/dev-guide --email bug-gnu-pspp\@gnu.org pspp-dev \"GNU PSPP Developers Guide\"", "dev-guide");
    saved_result ("Developers Guide", "dev-guide");
} else {
    $tarball = saved_result ("source distribution", $tarball);
}

if ($build_binary) {
    start_step ("Save tarball to Git");
    run ("GIT_DIR=$topdir/.git $topdir/git-import-tar $tarball refs/builds/$build_number/dist", "git-dist");
    set_var ("dist_ref", "refs/builds/$build_number/dist");
    set_var ("dist_commit", ref_to_commit ("refs/builds/$build_number/dist"));

    start_step ("Determining $tarball target directory");
    my $sample_filename = `zcat $tarball | tar tf - | head -1`;
    my ($tarball_dir) = $sample_filename =~ m%^(?:[./])*([^/]+)/%;
    set_var ("dist_dir", $tarball_dir);

    start_step ("Extracting source tarball");
    run ("zcat $tarball | (cd $builddir && tar xf -)");

    start_step ("Extracting tar version");
    my ($version) = `cd $builddir/$tarball_dir && ./configure --version | head -1`
      =~ /configure (\S+)$/;
    set_var ("dist_version", $version);
    my ($binary_version) = "$version-$build_host-build$build_number";
    set_var ("binary_version", $binary_version);

    start_step ("Configuring");
    run ("chmod -R a-w $builddir/$tarball_dir");
    run ("chmod u+w $builddir/$tarball_dir");
    run ("mkdir $builddir/$tarball_dir/_build");
    run ("chmod a-w $builddir/$tarball_dir");
    my $ok = try_run ("cd $builddir/$tarball_dir/_build && ../configure --enable-relocatable --prefix=''", "bin-configure");
    for my $basename ("config.h", "config.log") {
	save_result_if_exists ("build configuration",
			       "$builddir/$tarball_dir/_build/$basename");
    }
    fail () if !$ok;

    start_step ("Build");
    run ("cd $builddir/$tarball_dir/_build && make", "build");

    start_step ("Install");
    run ("cd $builddir/$tarball_dir/_build && make install DESTDIR=\$PWD/pspp-$binary_version", "install");

    start_step ("Make binary distribution");
    run ("cd $builddir/$tarball_dir/_build && tar cfz pspp-$binary_version.tar.gz pspp-$binary_version");
    save_result ("binary distribution", "$builddir/$tarball_dir/_build/pspp-$binary_version.tar.gz", 1);

    start_step ("Check");
    $ok = try_run ("cd $builddir/$tarball_dir/_build && make check", "check");
    for my $basename ("tests/testsuite.log", "tests/testsuite.dir") {
	save_result_if_exists ("test logs", "$builddir/$tarball_dir/_build/$basename");
    }
    fail () if !$ok;

    start_step ("Uninstall");
    run ("cd $builddir/$tarball_dir/_build && make uninstall DESTDIR=\$PWD/pspp-$binary_version", "uninstall");

    start_step ("Check uninstall");
    run ("cd $builddir/$tarball_dir/_build && make distuninstallcheck distuninstallcheck_dir=\$PWD/pspp-$binary_version", "distuninstallcheck");

    # distcleancheck
}

start_step ("Success");

sub usage {
    print <<EOF;
$0, for building and testing PSPP
usage: $0 [OPTIONS] [TARBALL | REPO REFSPEC]
where TARBALL is the name of a tarball produced by "make dist"
   or REPO and REFSPEC are a Git repo and refspec (e.g. branch) to clone.

Options:
  --help            Print this usage message and exit
  --no-binary       Build source tarballs but no binaries.
  --batch           Do not print progress to stdout.
EOF
    exit(0);
}

sub run {
    fail () if !try_run (@_);
}

sub try_run {
    my ($command, $id) = @_;

    print LOG "$command\n";

    my $pid = open (COMMAND, '-|');
    if (!defined ($pid)) {
	die "fork failed: $!\n";
    } elsif (!$pid) {
	dup2 (1, 2);
	exec ($command);
	die "$command: exec failed: $!\n";
    }

    my ($start) = time ();
    my ($est_time) = (defined ($id) ? read_timing ($id) : 0);

    local ($|) = 1;
    my $lines = 0;
    while (<COMMAND>) {
	print LOG $_;

	my $elapsed = time () - $start;
	my $progress = sprintf "%d lines logged, %d s elapsed",
	  $lines++, $elapsed;
	if ($est_time > 0) {
	    my $left = $est_time - $elapsed;
	    if ($left > 0) {
		$progress .= sprintf ", ETA %d s", $left;
	    }
	}
	print "\r$progress", " " x (79 - length ($progress)), "\r"
	  unless $batch;
    }
    close (COMMAND);
    print "\r", " " x 79, "\r" unless $batch;

    write_timing ($id, time () - $start) if defined ($id);

    return 1 if !$?;

    if ($? & 127) {
	printf STDERR "%s: child died with signal %d, %s coredump\n",
	  $command, ($? & 127),  ($? & 128) ? 'with' : 'without';
    } else {
	printf STDERR "%s: child exited with value %d\n", $command, $? >> 8;
    }
    return 0;
}

sub read_timing {
    my ($id) = @_;
    open (TIMINGS, "<", "$topdir/timings") or return 0;
    while (<TIMINGS>) {
	chomp;
	my ($key, $value) = /^([^=]+)=(.*)/ or next;
	return $value if $key eq $id;
    }
    close (TIMINGS);
    return 0;
}

sub write_timing {
    my ($id, $time) = @_;

    open (NEWTIMINGS, ">", "$topdir/timings.tmp$$") or return;

    if (open (OLDTIMINGS, "<", "$topdir/timings")) {
	while (<OLDTIMINGS>) {
	    if (my ($key, $value) = /^([^=]+)=(.*)/) {
		next if $key eq $id;
	    }
	    print NEWTIMINGS $_;
	}
	close (OLDTIMINGS);
    }

    print NEWTIMINGS "$id=$time\n";
    close (NEWTIMINGS);

    rename ("$topdir/timings.tmp$$", "$topdir/timings");
}

sub fail {
    die "Build failed, refer to:\n\t$logfile\nfor details.\n";
}