#!/usr/bin/env perl
#
# make-index-html
# John Simpson <jms1@jms1.net> 2023-07-23
#
# Create one or more 'index.html' files for use with web hosts that don't
# automatically generate index pages (such as Keybase Sites)
#
# 2023-08-13 jms1 - add support for per-directory `.title` files
#
# 2023-11-11 jms1 - added "generated" timestamp at end of page
#
# 2023-12-19 jms1 - no functional change, just adding a note to remind myself
#   in the future ... tried to add timestamps when listing child directories,
#   you can't just use the directory's mtime since writing a new `index.html`
#   file within a directory updates the directory's mtime ... you'll need to
#   scan and remember the timestamps of every file *within* that directory,
#   and use the highest timestamp *within* a directory, and you'll need to
#   scan all files recursively *before* generating *any* `index.html` files,
#   and this is more than i feel like doing right now.
#
# 2025-01-03 jms1
# - made the green "alternating lines" colour more faded (#c0f0c0 -> #e0f0e0)
# - added <!doctype html> to generated pages
#
# 2025-01-18 jms1
# - changing logic around options, `-T` is no longer needed
# - removed '-w' from shebang line, since some 'env' executables don't work
#   correctly if it's there. The 'use warnings' line below does the same thing.

require 5.005 ;
use strict ;
use warnings ;

use Getopt::Std ;

########################################
# Globals

my @dirs        = () ;      # list of directories waiting to be processed
my $root        = '' ;      # original root directory

########################################
# getopts

my %opt         = () ;
my $sorted      = 0 ;       # -s    generate "sorted" index pages
my $recursive   = 0 ;       # -r    process child directories
my $overwrite   = 0 ;       # -f    overwrite existing index pages
my $set_title   = '' ;      # -t:   manual title of root index page

###############################################################################
#
# usage

sub usage(;$)
{
    my $msg = ( shift || '' ) ;

    print <<EOF ;
$0 [options] [DIR]

Generate 'index.html' (and maybe 'index-s.html' and 'index-d.html') files
to provide index pages for directories hosted on a web server which doesn't
generate them automatically (such as Keybase Sites).

Each generated page's title will be the *first* of ...

* the value of the '-t' option
* the contents of a '.title' file, if it exists in that directory
* "Index of " followed by the directory name

DIR     The directory for which indexes should be generated. If not specified,
        the script will use '.' (the current directory).

-t ___  Title to use for the root page. If '-r' is used, the generated pages
        for child directories will have that directory's path *within* the
        root, appended to it.

-s      (sorted) Also generate indexes with the entries sorted in different
        orders. This will produce files with names like 'index-x.html' for
        different sorting types.

        Default is "by name" only, with directories above files.

-d      Print timestamps on directories.

-r      (recursive) Generate index pages for all child directories.

-f      (force) Overwrite existing 'index.html' and 'index-x.html' files.

-h      Show this help screen.

EOF

    if ( $msg ne '' )
    {
        print $msg ;
        exit 1 ;
    }

    exit 0 ;
}

###############################################################################
#
# Add commas to a number

sub add_commas($)
{
    my $x   = reverse $_[0];
    $x      =~ s/(\d\d\d)(?=\d)(?!\d*\.)/$1,/g;
    return ( scalar reverse $x ) ;
}

###############################################################################
#
# Write an index file

sub write_index($$$$;$$$$)
{
    my $outfile     = shift ;
    my $p_title     = shift ;
    my $r_dirs      = shift ;
    my $r_files     = shift ;
    my $header      = ( shift || '' ) ;
    my $footer      = ( shift || '' ) ;
    my $sort_by     = ( shift || '' ) ;
    my $show_parent = ( shift || 0  ) ;

    ########################################
    # If $p_title contains any HTML tags, don't include them in <title>

    my $t_title = $p_title ;
    $t_title =~ s|<.*?>||gs ;

    ########################################
    # Unless we've been told to overwrite files, make sure this file
    # doesn't already exist

    unless( $overwrite )
    {
        if ( -f $outfile )
        {
            print "  EXISTS  $outfile\n" ;
            return ;
        }
    }

    ########################################
    # Create the file

    print "  writing $outfile\n" ;

    open( my $fh , '>' , $outfile )
        or die "ERROR: can't write \"$outfile\": $!\n" ;

    ########################################
    # Write the header

    my $t   = time() ;
    my @d   = gmtime( $t ) ;
    my $now = sprintf( '%04d-%02d-%02dT%02d:%02d:%02d+00:00' ,
        $d[5]+1900 , $d[4]+1 , $d[3] , $d[2] , $d[1] , $d[0] ) ;

    print $fh <<EOF ;
<!doctype html>
<html>
<head>
<title>$t_title</title>
<!-- generated $t = $now -->
<style>
table {
    border          : 0 ;
    border-spacing  : 0 ;
}
tr:nth-child(even).list {
    background-color: #e0f0e0 ;
}
th {
    border-width    : 0 0 1px 0 ;
    border-style    : solid ;
    text-align      : left ;
}
td {
    padding         : 1px 0 0 0 ;
}
.name {
    text-align      : left ;
}
.size {
    text-align      : right ;
}
.date {
    text-align      : left ;
}
.sep {
    padding         : 0 10px ;
}
</style>
</head>
<body>
<h1><tt>$p_title</tt></h1>

$header

<hr/>

EOF

    ########################################
    # Start the table

    print $fh <<EOF ;

<table>
EOF

    ########################################
    # Build possible links within header row

    my $nl = '' ;
    my $sl = '' ;
    my $dl = '' ;
    my $el = '' ;

    if ( $sorted )
    {
        $nl = "<a href='index.html'>"   ;
        $sl = "<a href='index-s.html'>" ;
        $dl = "<a href='index-d.html'>" ;
        $el = '</a>'                    ;
    }

    ########################################
    # Write table header row

    print $fh <<EOF ;
  <tr>
    <th class='name'>$nl<tt>Name</tt>$el</th>
    <th class='sep'></th>
    <th class='size'>$sl<tt>Size</tt>$el</th>
    <th class='sep'></th>
    <th class='date'>$dl<tt>Date</tt>$el</th>
  </tr>
EOF

    ########################################
    # Write rows for child directories

    if ( $show_parent )
    {
        print $fh <<EOF ;
  <tr class='list'>
    <td class='name' colspan='5'><a href='../'><tt>../</tt></a></td>
  </tr>
EOF
    }

    for my $n ( sort keys %{$r_dirs} )
    {
        print $fh <<EOF ;
  <tr class='list'>
    <td class='name'><a href='$n/'><tt>$n/</tt></a></td>
    <td class='sep'></td>
    <td class='size'></td>
    <td class='sep'></td>
    <td class='date'></td>
  </tr>
EOF
    }

    ########################################
    # Figure out what order to show the files

    my @show = sort keys %{$r_files} ;

    if ( $sort_by eq 'size' )
    {
        @show = sort { $r_files->{$a}->{'size'} <=> $r_files->{$b}->{'size'} }
            keys %{$r_files} ;
    }
    elsif ( $sort_by eq 'date' )
    {
        @show = sort { $r_files->{$a}->{'mtime'} <=> $r_files->{$b}->{'mtime'} }
            keys %{$r_files} ;
    }

    ########################################
    # Write rows for files

    for my $n ( @show )
    {
        my $size    = add_commas( $r_files->{$n}->{'size'} ) ;
        my $mtime   = $r_files->{$n}->{'mtime'} ;

        my @d       = gmtime( $mtime ) ;
        my $date    = sprintf( '%04d-%02d-%02d %02d:%02d:%02d UTC' ,
            $d[5]+1900 , $d[4]+1 , $d[3] , $d[2] , $d[1] , $d[0] ) ;

        print $fh <<EOF ;
  <tr class='list'>
    <td class='name'><a href='$n'><tt>$n</tt></a></td>
    <td class='sep'></td>
    <td class='size'><tt>$size</tt></td>
    <td class='sep'></td>
    <td class='date'><tt>$date</tt></td>
  </tr>
EOF
    }

    ########################################
    # Finish the page

    print $fh <<EOF ;
</table>

<p>Generated <tt>$now</tt></p>

<hr/>

$footer

</body>
</html>
EOF

    close $fh ;
}

###############################################################################
#
# Read the contents of a directory and generate one or more index file(s).

sub process_dir($)
{
    my $dir = shift ;

    my $header = '' ;
    my $footer = '' ;

    ############################################################
    # Read directory's contents into memory

    my %ff = () ;       # filename => { (mtime|size) => value }
    my %dd = () ;       # dirname  => 1

    opendir( D , $dir )
        or die "ERROR: opendir(\"$dir\"): $!\n" ;

    while( my $f = readdir( D ) )
    {
        ########################################
        # Certain filenames need to be ignored

        next if ( $f =~ m|^\.| ) ;

        next if ( $f eq 'index.html'   ) ;
        next if ( $f eq 'index-s.html' ) ;
        next if ( $f eq 'index-d.html' ) ;

        ########################################
        # If a HEADER.html or FOOTER.html file exsits, remember its contents
        # and don't show the file in the output.

        if ( $f eq 'HEADER.html' )
        {
            print "  reading HEADER.html\n" ;

            open( H , '<' , "$dir/$f" )
                or die "ERROR: can't read \"$dir/$f\": $!\n" ;
            undef $/ ;
            $header = <H> ;
            close H ;

            next ;
        }

        if ( $f eq 'FOOTER.html' )
        {
            print "  reading FOOTER.html\n" ;

            open( H , '<' , "$dir/$f" )
                or die "ERROR: can't read \"$dir/$f\": $!\n" ;
            undef $/ ;
            $footer = <H> ;
            close H ;

            next ;
        }

        ########################################
        # Read/remember info about this entry

        if ( -f "$dir/$f" )
        {
            my @s = stat( "$dir/$f" ) ;
            $ff{$f}->{'size'}  = $s[7] ;
            $ff{$f}->{'mtime'} = $s[9] ;
        }
        elsif ( -d "$dir/$f" )
        {
            my @s = stat( "$dir/$f" ) ;
            $dd{$f}->{'mtime'} = $s[9] ;

            if ( $recursive )
            {
                push( @dirs , "$dir/$f" ) ;
            }
        }
    }

    closedir D ;

    ############################################################
    # Build the title for this index

    my $sub = $dir ;
    $sub =~ s|^$root|| ;

    my $p_title = '' ;

    if ( $set_title ne '' )
    {
        $p_title = $set_title . $sub ;
    }
    elsif ( -f "$dir/.title" )
    {
        $p_title = '' ;
        open( T , '<' , "$dir/.title" )
            or die "ERROR: can't read \"$dir/.title\": $!\n" ;
        while ( my $line = <T> )
        {
            $p_title .= $line ;
        }
        close T ;

        $p_title =~ s|\s+$||s ;
    }
    else
    {
        $p_title = "Index of $root$sub" ;
    }

    ########################################
    # Write 'index.html'

    my $sp = ( $dir ne $root ) ? 1 : 0 ;

    write_index( "$dir/index.html" , $p_title , \%dd , \%ff ,
        $header , $footer , '' , $sp ) ;

    ########################################
    # If we're doing "sorted by" versions, generate those pages as well

    if ( $sorted )
    {
        write_index( "$dir/index-s.html" , $p_title , \%dd , \%ff ,
            $header , $footer , 'size' , $sp ) ;
        write_index( "$dir/index-d.html" , $p_title , \%dd , \%ff ,
            $header , $footer , 'date' , $sp ) ;
    }
}

###############################################################################
###############################################################################
###############################################################################
#
# Process the command line

getopts( 'hsrft:' , \%opt ) ;
$opt{'h'} && usage() ;
$sorted     = ( $opt{'s'} ? 1 : 0 ) ;
$recursive  = ( $opt{'r'} ? 1 : 0 ) ;
$overwrite  = ( $opt{'f'} ? 1 : 0 ) ;
$set_title  = ( $opt{'t'} || '' ) ;

$root = ( shift || '.' ) ;
$root =~ s|/$|| ;
push( @dirs , $root ) ;

########################################
# Process the list of directories.
#
# When the script starts, the list only contains the directory that was
# specified on the command line.
#
# If $recursive is true, other directories *may* be added to the list as
# they are found.

while ( my $d = shift @dirs )
{
    print "processing '$d'\n" ;
    process_dir( $d ) ;
}