#!/usr/bin/perl

package kappa;
use strict;


$kappa::depth = 0;


sub show_bigs {
    &kappa::show_generic_scan($_[0], 1);
    &kappa::show_generic_print($_[0], 1);
}

sub show_littles {
    &kappa::show_generic_scan($_[0], 2);
    &kappa::show_generic_print($_[0], 2);
}

sub show_generic_scan {
    my $i;
    my $little;
    my $bro = $_[0];
    my $dir = $_[1];
    my $list;

    if ($kappa::seen{$bro}) {
        if ($kappa::seen{$bro} < $kappa::depth) {
            return;
        }
    }
    $kappa::seen{$bro} = $kappa::depth;
    
    $kappa::depth++;
    if ($dir == 1) {
        $list = $kappa::bigs{$bro};
    } else {
        $list = $kappa::littles{$bro};
    }
    if ($list) {
        foreach $little (sort split / /, $list) {
            &kappa::show_generic_scan($little, $dir);
        }
    }
    $kappa::depth--;
}

sub show_generic_print {
    my $i;
    my $big;
    my $bro = $_[0];
    my $dir = $_[1];
    my $list;

    printf "%02d ", $kappa::depth;
    $i = 0;
    while ($i <= $kappa::depth) {
        print "  ";
        $i++;
    }
    printf " %s %s\n", $bro, $kappa::names{$bro};

    if ($kappa::seen{$bro} == -1 || $kappa::seen{$bro} < $kappa::depth) {
        print "                    ...\n";
        return;
    }

    $kappa::seen{$bro} = -1;
    
    $kappa::depth++;
    if ($dir == 1) {
        $list = $kappa::bigs{$bro};
    } else {
        $list = $kappa::littles{$bro};
    }
    if ($list) {
        foreach $big (sort split / /, $list) {
            &show_generic_print($big, $dir);
        }
    }
    $kappa::depth--;
}


sub do_big {
    my $little = $_[0];
    my $big = $_[1];
    my $temp;

    if (!$big || !$little) {
        return;
    }
    
    if (exists $kappa::bigs{$little}) {
        $temp = $kappa::bigs{$little};
    } else {
        $temp = "";
    }
    $temp = "$big $temp";
    $kappa::bigs{$little} = $temp;

    if (exists $kappa::littles{$big}) {
        $temp = $kappa::littles{$big};
    } else {
        $temp = "";
    }
    $temp = "$little $temp";
    $kappa::littles{$big} = $temp;
}


sub make_brother_lists {
    if (! open(INFILE, "cat brothers.dat |")) {
        die "opening brothers.dat";
    }
    while (<INFILE>) {
        # clean the record and divide it
        my @rec = &kappa::break_line;
        
        next if $rec[0] =~ /^PNI$/;
        next if $rec[0] =~ /^ANI$/;
        
        &kappa::do_big($rec[0], $rec[32]);
        &kappa::do_big($rec[0], $rec[33]);
        &kappa::do_big($rec[0], $rec[34]);
        &kappa::do_big($rec[0], $rec[35]);
        $kappa::names{$rec[0]} = &kappa::build_name(@rec);
        $kappa::dates{$rec[0]} = $rec[3];
    }
    close(INFILE);
}
    

sub break_line {
    my $tmp = sprintf("%s_quote%s",
                      &kappa::m4_quote(""),
                      &kappa::m4_quote(""));
    s/\\\'e/&eacute;/g;
    s/\\;u/&uuml;/g; # using \: does bad things to breaking lines on :
    s/\\~a/&atilde;/g;
    s/\'/$tmp/g;
    chop;
    $_ = "$_" . "::::::::::::::::::::::::::::::X";
#    print STDERR $_;
    split(/:/);
}


sub build_name {
    sprintf("%s%s %s%s%s",
            &kappa::ifnb($_[4], "$_[4] "),
            $_[5],
            &kappa::ifnb($_[6], "\"$_[6]\" "),
            $_[7],
            &kappa::ifnb($_[8], ", $_[8]"));
}

sub build_reversed_name {
    sprintf("%s, %s%s%s%s",
            $_[7], $_[5],
            &kappa::ifnb($_[6], " \"$_[6]\""),
            &kappa::ifnb($_[8], ", $_[8]"),
            &kappa::ifnb($_[4], ", $_[4]"));
}


# evaluate to the second argument if the first is not blank, else nothing
sub ifnb {
    my $ifnb_tmp = "";
    if ($_[0]) {
        $ifnb_tmp = $_[1];
    } else {
        $ifnb_tmp = "";
    }
}


# convert an ISO date to a more readable format
sub clean_date {
    my $clean_date_rec = $_[0];

    if ($clean_date_rec =~ /^[A-Za-z]+/) {
        $clean_date_rec = "";
        return;
    }

    my @months = ("", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");

    @_ = split(/-/, "${clean_date_rec}-00-00-00");
    my $yr = $_[0];
    my $mo = $_[1];
    my $dy = $_[2];

    $dy =~ s/00//;
    $dy =~ s/^0//;
    $mo =~ s/^0//;

    my $comma = "";
    if ($mo) {
        $comma = ", ";
    }

    my $space = "";
    if ($dy) {
        $space = " ";
    }
    my $clean_date = "$months[$mo]$space$dy$comma$yr";
}


# read a file to stdout
sub read_file {
    my $read_file_name = $_[0];
    if (! open(READ_FILE_INFILE, $read_file_name)) {
	die "opening $read_file_name";
    }
    while (<READ_FILE_INFILE>) {
        print;
    }
    close READ_FILE_INFILE;
}


# evaluate to the first argument in m4-style quotes
sub m4_quote {
    my $m4_quote = "\140$_[0]\'";
}


sub pr_rec {
    print "_mem_rec(";
    my $i = 0;
    while ($i < 30) {
        if ($i != 0) {
            print ",";
        }
        if ($i == 3) {
            print &m4_quote(&clean_date($_[$i]));
        } else {
            print &m4_quote($_[$i]);
        }

        $i++;
    }
    print ")\n";
}


# read in class info
if (! open(INFILE, "<class.dat")) {
    die "opening class.dat";
}
while (<INFILE>) {
    my $date;
    my $namesake;
    my $note;
    my $pres;
    my $presofc;
    my $mvp;
    my $mvpofc;

    my $tmp = sprintf("%s_quote%s", &m4_quote(""), &m4_quote(""));
    s/\'/$tmp/g;
    chop;
    ($date,$namesake,$note,$pres,$presofc,$mvp,$mvpofc) = split(/:/,$_);
    if ($namesake) {
        $kappa::namesakes{$date} = $namesake;
    }
    $kappa::notes{$date} = $note;
    $kappa::press{$date} = $pres;
    $kappa::presofcs{$date} = $presofc;
    $kappa::mvps{$date} = $mvp;
    $kappa::mvpofcs{$date} = $mvpofc;
}
close INFILE;


# end of common block

# need to return a true value
1;

# EOF