#!/usr/bin/perl
# This script uses standard 8-space tabs with 4-space indents
# vi users can :set sw=4 ai sm

use Getopt::Long;
use vars qw( $verbose_p );

GetOptions(
    'verbose|v' => \$verbose_p,
) || exit(1);

print <<EOM;
***************************************
* Welcome to the Koha Release Builder *
***************************************
EOM

#----------------------------------------------------------
# To guess the version, we need to first guess where this
# script itself is Otherwise we will have different results
# depending on whether the script is called as ./buildrelease
# or misc/buildrelease. If we run the script from misc, we
# will also get errors from "cvs update" later, so this is
# rather important information
#----------------------------------------------------------
print STDERR "Perl reports that buildrelease is $0\n" if $verbose_p;
my $self_path;
if ($0 =~ /^(\.\/)*buildrelease$/) {
    $self_path = 'buildrelease';
} elsif ($0 =~ /^(?:(\.\/)*\/)?misc\/buildrelease$/) {
    $self_path = 'misc/buildrelease';
} else {
    print <<EOM;

WARNING: Unable to determine where the buildrelease script is located.
         The version number guessed by the next step might be wrong.
EOM
    $self_path = (-f 'buildrelease')? 'buildrelease': 'misc/buildrelease';
}
print STDERR "Assuming buildrelease is $self_path\n" if $verbose_p;

#----------------------------------------------------------
# Fixup the current directory
#----------------------------------------------------------
if ($self_path eq 'buildrelease') {
    print <<EOM;

WARNING: You should run the buildrelease script from the top of the koha
         CVS module.  I will try to change to the correct directory, but
         it is better if you had ran this script there in the first place.
EOM
    chdir ".." || die "..: chdir: $!\n";
    $self_path = 'misc/buildrelease';
}

#----------------------------------------------------------
# Start the release builder
#----------------------------------------------------------
#sub guess_kohahtmldir ($;$);
#----------------------------------------------------------
# DIRECTORIES where source code is located
#----------------------------------------------------------
my $kohadir=`pwd`;
chomp $kohadir;
#my $kohahtmldir=guess_kohahtmldir($kohadir, "/koha/koha/koha-html/");
my $roothomedir=(getpwuid(0))[7];	# ~root is traditionally just /
$roothomedir='/root' unless defined $roothomedir;

my $has_kohaautobuild_conf = 0;

if (-e "$roothomedir/.kohaautobuild.conf") {
    print STDERR "$roothomedir/.kohaautobuild.conf found\n" if $verbose_p;
    open C, "<$roothomedir/.kohaautobuild.conf";
    while (<C>) {
	chomp;
	if (/kohadir=(.*)/) {
	    $kohadir=$1;
	}
#	if (/kohahtmldir=(.*)/) {
#	    $kohahtmldir=$1;
#	}
    }
    $has_kohaautobuild_conf = 1;
}

my $input;

print qq |
This script will automatically build a release tarball.

The script assumes that you already have the koha and koha-html modules checked
out for the release that you want to build, although it will update the modules
before building.
|;
print "\nWhere is the 'koha' cvs module located? [$kohadir]: ";
chomp($input = <STDIN>);
if ($input) {
    $kohadir=$input;
#    unless ($has_kohaautobuild_conf) {
#	$kohahtmldir=guess_kohahtmldir($kohadir, $kohahtmldir);
#    }
}


#print "\nWhere is the 'koha-html' cvs module located [$kohahtmldir]: ";
#chomp($input = <STDIN>);
#if ($input) {
#    $kohahtmldir=$input;
#}

open (C, ">$roothomedir/.kohaautobuild.conf");
print C qq|
kohadir=$kohadir
#kohahtmldir=$kohahtmldir
|;
print STDERR "$roothomedir/.kohaautobuild.conf written\n" if $verbose_p;

#----------------------------------------------------------
# which VERSION are we building ?
#----------------------------------------------------------
print <<EOM;

Guessing the next release version. You may need to enter your SourceForge password.
EOM
chdir $kohadir;
open (CVSLOG, "cvs log $self_path|");
my $symbolicnamessection=0;
my $symbolicnames;
my $highestversion;
my $highestrc;
my $released;
my $majorversion;
my $majorversionrc;
while (<CVSLOG>) {
    if (/^symbolic names:/) {
	$symbolicnamessection=1;
	print STDERR "Scanning symbolic names from cvs output\n" if $verbose_p;
    }
    if ($symbolicnamessection && (/^\s+([^:]*):/)) {
	my $tag=$1;
	if ($tag=~/(?:R|rel)_(.*)/) {
	    my $version='';
	    my $rc=0;
	    my $id=$1;
	    $id =~ s/[-_]/\./g;
	    print STDERR "Found a tag for release $id\n" if $verbose_p;
	    if ($id =~/(.*)RC(.*)/) {
		$version=$1;
		$rc=$2;
		$version =~ /^(\d+\.\d+)(?:\.|[RC]|$)/;
		if (versioncompare($version, $majorversion->{$1})) {
		    $majorversion->{$1}=$version;
		    $majorversionrc->{$1}=$rc;
		    print STDERR "Setting major version for $1 to $version $rc\n" if $verbose_p;
		}
		if (versioncompare($version, $highestversion)) {
		    $highestversion=$version;
		    $released=0;
		    $highestrc=$rc;
		    print STDERR "Setting highest version to $highestversion $highestrc\n" if $verbose_p;
		}
	    } else {
		$version=$id;
		$version =~ /^(\d+\.\d+)(?:\.|[RC]|$)/;
		if (versioncompare($version, $majorversion->{$1})) {
		    $majorversion->{$1}=$version;
		    $majorversionrc->{$1}=0;
		    print STDERR "Setting major version for $1 to $version $rc\n" if $verbose_p;
		}
		if (versioncompare($version, $highestversion)) {
		    $highestversion=$version;
		    $released=1;
		    $highestrc=0;
		    print STDERR "Setting highest version to $highestversion $highestrc\n" if $verbose_p;
		}
	    }
	    $symbolicnames->{$version}->{$rc}=1;
	    print STDERR "Setting symbolic name mapping for version $version $rc to 1\n" if $verbose_p;
	}
    }
}

my $releaseversion='';
my $currentversion='';

my $cvs_entries_path = $self_path;
$cvs_entries_path =~ s/[^\/]+$/CVS\/Entries/;
print STDERR "Assuming CVS/Entries is $cvs_entries_path\n" if $verbose_p;

my $branchdata=`grep buildrelease $cvs_entries_path`;
chomp $branchdata;
my $branch=(split(m#/#, $branchdata))[5];
$branch =~ s/^T//;
$branch =~ s/^(?:R|rel)_//;
$branch =~ s/[-_]/./g;
print STDERR "Detected branch $branch\n" if $verbose_p;

if ($branch =~ /\S/ && defined $majorversion->{$branch}) {
    $highestversion=$majorversion->{$branch};
    $highestrc=$majorversionrc->{$branch};
    ($highestrc) ? ($released=0) : ($released=1);
    print STDERR "Using highest version for branch $branch\n" if $verbose_p;
}

if ($released) {
    my @components=split(/\./, $highestversion);
    if (@components < 3) { # if it's something like just 2.2 or 2.4
	$releaseversion = $highestversion.".1RC1";
    } else {
	$components[$#components]++;
	$nexthighestversion=join '.', @components;
	my $minornumber=(split(/\./, $highestversion))[1];
	if ($minornumber/2 == int($minornumber/2)) {
	    $releaseversion=$nexthighestversion."RC1";
	} else {
	    $releaseversion=$nexthighestversion;
	}
    }
    $currentversion=$highestversion;
} else {
    $releaseversion=$highestversion."RC".($highestrc+1);
    $currentversion=$highestversion."RC$highestrc";
}


print "Current release tag is $currentversion.\n";
print "\nWould you like to bump that up to $releaseversion (or manually enter version)?  [Y]/N: ";
chomp($input = <STDIN>);
my $tagging_needs_confirmation = 0;
if ($input =~ /^n/i) {
    print "\nWould you like to rebuild the $currentversion tarball?  Y/[N]: ";
    chomp($input = <STDIN>);
    if ($input =~ /^y/i) {
	$releaseversion=$currentversion;
	$tagging_needs_confirmation = 1;
    } else {
	print "What should the new version be? [$releaseversion]: ";
	chomp ($input=<STDIN>);
	if ($input) {
	    $releaseversion=$input;
	}
    }
} else {
    print "What should the new version be? [$releaseversion]: ";
    chomp ($input=<STDIN>);
    if ($input) {
	$releaseversion=$input;
    }
}


print "\nWould you like to tag the CVS repository?\n(answer yes if releasing tarball)  Y/[N]: ";
chomp ($input=<STDIN>);
my $cvstag=0;
if ($input=~/^y/i) {
    $cvstag=1;
}
print "The CVS repository ",($cvstag?"WILL BE TAGGED\n":"will not be tagged\n");


if ($cvstag && $tagging_needs_confirmation) {
	print "\n\n";
	print "Do not do this if you have released the tarball to anybody, as it will\n";
	print "overwrite the tag marking the files that were in the tarball:\n\n";
	print "Confirm that you want to overwrite the tag for $releaseversion? Y/[N]: ";
	chomp($input = <STDIN>);
	if ($input =~ /^n/i || $input !~ /\S/) {
	    print "\nStopping.  Please re-run buildrelease now.\n";
	    exit;
	}
}


my $sfuserid='';
if ($cvsroot=$ENV{'CVSROOT'}) {
    $cvsroot=~m#(.*)\@cvs#;
    $sfuserid=$1;
} else {
    $ENV{'CVS_RSH'}='ssh';
    print "\nWhat is your userid at SourceForge: ";
    chomp($input = <STDIN>);
    if ($input) {
	$sfuserid=$input;
    }
    $ENV{'CVSROOT'}="$sfuserid\@cvs.koha.sourceforge.net:/cvsroot/koha";
}
my $tagname=$releaseversion;
$tagname=~s/\./-/g;

print qq|
Updating your checked-out copy of the 'koha' CVS files.
You may need to enter your SourceForge password.
Using $kohadir.
|;
chdir($kohadir) || die "$kohadir: $!\n";
# system("cvs update -P");
if ($cvstag) {
    print qq|
Tagging koha with tag R_$tagname
|;
    system("cvs tag -F R_$tagname");
}

#----------------------------------------------------------
# MOVE files to /tmp and build tar.gz
#----------------------------------------------------------

my $rootdir="/tmp/koha-".$releaseversion;
system("rm -rf $rootdir");
mkdir ($rootdir, 0700);
chdir($rootdir) || die "$rootdir: $!\n";

mkdir("intranet-cgi", 0755);
mkdir("intranet-html", 0755);
mkdir("opac-cgi", 0755);
mkdir("opac-html", 0755);
mkdir("scripts", 0755);
mkdir("scripts/z3950daemon", 0755);
mkdir("modules", 0755);
mkdir("docs", 0755);

# Create koha.version file
open (KV, ">$rootdir/koha.version");
print KV "$releaseversion\n";
close KV;

# Copy all CVS files to intranet-cgi
# FIXME: "cp -a" is GNU-ism. It is not portable.
system("cp -a $kohadir/* $rootdir/intranet-cgi");

# Move C4 to modules directory
system("mv $rootdir/intranet-cgi/C4 $rootdir/modules");

# Move files from intranet-cgi to root of tarball
system("mv $rootdir/intranet-cgi/misc/info/* $rootdir");
system("mv $rootdir/intranet-cgi/misc/installer.pl $rootdir");
system("mv $rootdir/intranet-cgi/misc/koha.upgrade $rootdir");
system("mv $rootdir/intranet-cgi/misc/Install.pm $rootdir");
#system("mv $rootdir/intranet-cgi/kohareporter $rootdir"); # does not exist ??
chmod 0770, "$rootdir/installer.pl";
chmod 0770, "$rootdir/koha.upgrade";
system("mv $rootdir/intranet-cgi/misc/koha.conf $rootdir");
system("mv $rootdir/intranet-cgi/misc/koha.mysql $rootdir");
system("mv $rootdir/intranet-cgi/misc/sampledata-1.2 $rootdir");
system("gzip -9 $rootdir/sampledata-1.2");

# Copy files from intranet-cgi to opac-cgi
system("cp $rootdir/intranet-cgi/detail.pl $rootdir/opac-cgi");
system("cp $rootdir/intranet-cgi/moredetail.pl $rootdir/opac-cgi");
system("cp $rootdir/intranet-cgi/search.pl $rootdir/opac-cgi");
system("cp $rootdir/intranet-cgi/subjectsearch.pl $rootdir/opac-cgi");
system("cp $rootdir/intranet-cgi/logout.pl $rootdir/opac-cgi");
system("mv $rootdir/intranet-cgi/opac/* $rootdir/opac-cgi");
system("rmdir $rootdir/intranet-cgi/opac");


# Move files from intranet-cgi to /scripts/ directory
system("mv $rootdir/intranet-cgi/updater $rootdir/scripts");
system("mv $rootdir/intranet-cgi/misc $rootdir/scripts");

# move only batch & daemon. pl script stay here
system("mv $rootdir/intranet-cgi/z3950/processz3950queue $rootdir/scripts/z3950daemon/");
system("mv $rootdir/intranet-cgi/z3950/*.sh $rootdir/scripts/z3950daemon/");

# Remove extraneous files from intranet-cgi
system("rm -f $rootdir/intranet-cgi/ChangeLog.bak");
system("rm -f $rootdir/intranet-cgi/SendMessages");
system("rm -f $rootdir/intranet-cgi/buildrelease");
system("rm -rf $rootdir/intranet-cgi/t");

# Set all .pl scripts executable
system("find $rootdir/intranet-cgi -name '*.pl' -exec chmod a+x \\{\\} \\;");
# Copy all CVS files to intranet-html and opac-html
# FIXME: "cp -a" is GNU-ism. It is not portable.
#system("cp -a $kohahtmldir/intranet-html/* $rootdir/intranet-html");
#system("cp -a $kohahtmldir/opac-html/* $rootdir/opac-html");

# Copy koha-tmpl files
# FIXME: "cp -a" is GNU-ism. It is not portable.
system('cp', '-a', "$rootdir/intranet-cgi/koha-tmpl/opac-tmpl", "$rootdir/opac-html");
system('cp', '-a', "$rootdir/intranet-cgi/koha-tmpl/intranet-tmpl", "$rootdir/intranet-html");
#copy index files (they are just redirections to main.pl)
system("cp $rootdir/intranet-cgi/koha-tmpl/opac.html $rootdir/opac-html/index.html");
system("cp $rootdir/intranet-cgi/koha-tmpl/intranet.html $rootdir/intranet-html/index.html");
system('rm', '-rf', "$rootdir/intranet-cgi/koha-tmpl");

# Remove junk from directory
system("find $rootdir -name CVS -exec rm -rf \\{\\} \\; 2>/dev/null");
system("find $rootdir -name *~ -exec rm -rf \\{\\} \\; 2>/dev/null");
system("find $rootdir -name .#* -exec rm -rf \\{\\} \\; 2>/dev/null");

chdir("/tmp");
system("tar czf /tmp/koha-$releaseversion.tar.gz koha-".$releaseversion);
system("rm -rf $rootdir");

print qq|
============
= ALL DONE =
============

Your new tarball is located in /tmp/koha-$releaseversion.tar.gz

|;


# Given two version numbers (v1, v2), returns 0 if v1 <= v2, or 1 if v1 > v2
sub versioncompare {
    my $v1=shift;
    my $v2=shift;
    my @v1=split(/\./, $v1);
    my @v2=split(/\./, $v2);
    my $count=$#v1;
    ($#v2>$count) && ($count=$#v2);
    for (my $index=0; $index<$count; $index++) {
	if ($v1[$index]>$v2[$index]) {
	    return 1;
	}
    }
    return 0;
}

#sub guess_kohahtmldir ($;$) {
#    my($kohadir, $default) = @_;
#    my $kohahtmldir;
    # It probably makes sense to assume that the 'koha' and 'koha-html'
    # modules are checked out within the same parent directory
#    if (-d $kohadir && $kohadir =~ /^(.*)\/[^\/]+$/) {
#	$kohahtmldir = "$1/koha-html"
#    } else {
#	$kohahtmldir = $default;
#    }
#    return $kohahtmldir;
#}