#!/opt/perl5/bin/perl -w
##  
##  Split a file into 'num' equal-size chunks, or into chunks with 
##  at most 'num' lines each.
##
##  Usage:
##     chunkify <-n num | -l num> [-v] [-o <output name>] 
##         [-f <footer>] [-h <header>]  <input file>
##
#

use strict;
use Getopt::Std;

my ($verbose, $outfront, $outback, $froot, $chunks, $lines);
my ($infile, $headfile, @headlines, $footfile, @footlines);
my ($rem,@line,$fname,$x,$y,$opts);
my (%Options);

##
##  Right now, assume the output file is based on the input file.
##  This can be overridden by the -f option.
##
$infile = $ARGV[$#ARGV];
$froot = $infile;

$opts = getopts ('vo:h:f:n:l:',\%Options);

$lines=0;
$chunks=0;

if ($opts) {
	if ($Options{v}) {
		$verbose=$Options{v};
	}
	if ($Options{o}) {
		$froot = $Options{o};             
	}
	if ($Options{l} && $Options{n}) {
		print "\nERROR: Cannot use -l and -n simultaneously.\n";
		exit(1);
	}
	if (! $Options{l} && ! $Options{n}) {
		print "\nERROR: Either -n or -l must be specified.\n";
		exit (1);
	}
	if ($Options{n}) {
		$chunks=$Options{n};
	}
	if ($Options{l}) {
		$lines=$Options{l};
	}
	if ($Options{f}) {
		$footfile=$Options{f};
	}
	if ($Options{h}) {
		$headfile=$Options{h};
	}
		
} else {
	if (exists $Options{n} && !defined $Options{n}) {
		print "\nERROR: -n requires a numeric argument if used.\n";
	}
	if (exists $Options{l} && !defined $Options{l}) {
		print "\nERROR: -l requires a numeric argument if used.\n";
	}
	if (exists $Options{o} && !defined $Options{o}) {
		print "\nERROR: -o requires a filename if used.\n";
	}
	if (exists $Options{h} && !defined $Options{h}) {
		print "\nERROR: -h requires a filename if used.\n";
	}	
	if (exists $Options{f} && !defined $Options{f}) {
		print "\nERROR: -f requires a filename if used.\n";
	}
	ShowUsage();
}

$x=0;
$y=1;

($outfront,$outback) = split ("%",$froot);


##
##  If header and/or footer files were specified, get their contents
##

if (defined $headfile) {
	open (INFILE, $headfile) || die "Could not open header file $headfile: $!";
	@headlines = <INFILE>;
	close (INFILE)
}

if (defined $footfile) {
	open (INFILE, $footfile) || die "Could not open footer file $footfile: $!";
	@footlines = <INFILE>;
	close (INFILE)
}

open (INFILE, $infile) || die "Could not open file $infile: $!";

##
##  Either we were given the "lines" option, or we were given the "chunks" option.
##  If we got chunks, we need to figoure out how many lines that's going to be, and
##  the only way is to read through the file, counting lines.
##


if ($chunks != 0) {
	while (<INFILE>) {
		$x++;
	}
	$lines = sprintf "%d", ($x / $chunks);
##  Did it divide out evenly? (eg: 141 lines into 13 "equal" files ain't evenly)
##  If not, some files will need an extra line.
	foreach $y (1..$chunks) {
		$line[$y]=$lines
	}
	$rem = $x - ($chunks * $lines);
	if ($rem != 0) {
		foreach $y (1..$rem) {
			$line[$y]++;
		}
	}	
	print "Input file has $x lines; will put at least $lines lines in each output file.\n" if $verbose;
	close INFILE || die "ERROR: Could not close $infile: $!";
        open (INFILE, $infile) || die "Could not open file $infile: $!";;
}
	
$y=0;
until (eof INFILE) {
	$y++;
	if (defined $outback) {
		$fname = $outfront . (sprintf "%0.3d",$y) . $outback; 
        } else {
		$fname = $outfront . (sprintf "%0.3d",$y);
	}
	$lines= $line[$y] if (defined $line[$y]);
	print "Creating $fname with $lines lines\n" if $verbose;
	write_chunk();

}

close (INFILE);

sub write_chunk {
	open (OUTFILE,">$fname") || die "ERROR Could not open output file $fname: $!";
	$x=0;
	if (@headlines) {
		print OUTFILE @headlines || die "ERROR writing header to $fname: $!";
	}
	while(<INFILE>) {
		print OUTFILE $_ || die "ERROR writing to output file $fname: $!";
		$x++;
		last unless $x % $lines;  
	}
	if (@footlines) {
		print OUTFILE @footlines || die "ERROR writing footer to $fname: $!";
	}
	close OUTFILE || die "ERROR closing $fname: $!";
}

sub ShowUsage {
	print <<EOD;

Usage: chunkify.pl <-n num | -l num> [-o <output filename>] [-v] 
        [-h <header text file>] [-f <footer text file>] <input file name>

Required paremeters (specify only one):
   -n : split input file name into 'num' (more-or-less) equal-size files.
   -l : split input file into files with 'num' lines.
   In most cases, not all output files will have the same number of lines. If -l is used,
     each file will have that many lines, except for the last file, which may have fewer.
     If -n is used, each file will have X or X+1 lines, where X is calculated based on 
     number of output files required and size of the input file.
Optional parameters:
   -v : verbose output
   -o : output file name. Use % sign to indicate position of sequence number. If % not
        specified, sequence number will be appended. 
	Examples:
	   file%.txt: will generate file001.txt, file002.txt, file003.txt ...
	   file.txt: will generate file.txt001, file.txt002, file.txt003 ...
	   %file: will generate 001file, 002file, 003file ...
	If -o is not specified, output filename will be built from input file name, with 
	sequence number appended.
   -h : file containing text to be prepended to each created output file.
   -f : file containing text to be appended to each created output file.
EOD
}