#!/usr/bin/perl

use strict;
use warnings;
use TUWF ':html', 'html_escape', ':xml';
use JSON::XS;

use Cwd 'abs_path';
our $ROOT;
BEGIN { ($ROOT = abs_path $0) =~ s{/www/index\.pl$}{}; }


use lib "$ROOT/lib/ManUtils/inst/lib/perl5";
use ManUtils;


TUWF::set(
  logfile => $ENV{TUWF_LOG},
  db_login => [undef, undef, undef],
  debug => 0,
  xml_pretty => 0,
  # Cache the system information
  pre_request_handler => sub {
    my $self = shift;
    if(!$self->{systems}) {
      $self->{systems} = $self->dbSystemGet;
      $_->{full} = $_->{name}.($_->{release}?' '.$_->{release}:'') for(@{$self->{systems}});
      $self->{sysbyid} = { map +($_->{id}, $_), @{$self->{systems}} };
      $self->{sysbyshort} = { map +($_->{short}, $_), @{$self->{systems}} };
    }
    1;
  },
  error_404_handler => sub {
    my $self = shift;
    $self->resStatus(404);
    my $title = 'No manual entry for '.$self->reqPath;
    $self->htmlHeader(title => $title);
    h1 $title;
    p 'That is, the page you were looking for doesn\'t exist.';
    $self->htmlFooter;
  },
);


TUWF::register(
  qr// => \&home,
  qr{info/about} => \&about,
  qr{browse/search} => \&browsesearch,

  qr{pkg/([^/]+)} => \&pkg_list,
  # pkg/$system/$category/$name (/$version); $category may contain a slash, too.
  qr{pkg/([^/]+)/(.+)?} => \&pkg_info,

  # Redirects for old URLs.
  # /browse/<pkg> has been moved to /pkg/ with the package category added to the path
  qr{browse/([^/]+)} => sub { $_[0]->resRedirect("/pkg/$_[1]", 'perm'); },
  qr{browse/([^/]+)/([^/]+)(?:/([^/]+))?} => sub {
    my($self, $sys, $name, $ver) = @_;
    $sys = $self->{sysbyshort}{$sys};
    return $self->resNotFound if !$sys;
    my $pkgs = $self->dbPackageGet(sysid => $sys->{id}, name => $name, results => 1);
    return $self->resNotFound if !@$pkgs;
    $self->resRedirect("/pkg/$sys->{short}/$pkgs->[0]{category}/$name".($ver ? "/$ver" :''), 'perm');
  },

  qr{xml/search\.xml} => \&xmlsearch,
  qr{([^/]+)/([0-9a-f]{8})} => \&man,
  qr{([^/]+)/([0-9a-f]{8})/src} => \&src,
  qr{([^/]+)} => \&man,
);

TUWF::run();


sub home {
  my $self = shift;
  my $stats = $self->dbStats;
  my $fn = sub { local $_=shift; 1 while(s/(\d)(\d{3})($|,)/$1,$2/); $_ };
  $self->htmlHeader(title => 'Man Pages Archive');
  h1 'Man Pages Archive';
  p; lit sprintf <<'  _', map $fn->($stats->{$_}), qw|hashes mans files packages|;
   Indexing <b>%s</b> versions of <b>%s</b> manual pages found in <b>%s</b>
   files of <b>%s</b> packages.
   <br /><br />
   Manned.org aims to index all manual pages from a variety of systems, both
   old and new, and provides a convenient interface for looking up and viewing
   the various versions of each man page.
   <a href="/info/about">About manned.org &raquo;</a>
  _
  end;

  h2 'Browse the manuals';
  ul id => 'systems';
   my %sys;
   push @{$sys{$_->{name}}}, $_ for(@{$self->{systems}});
   for my $sys (sort keys %sys) {
     $sys = $sys{$sys};
     (my $img = $sys->[0]{short}) =~ s/^(.+)-.+$/$1/;
     li;
      a href => "/pkg/$sys->[0]{short}" if @$sys == 1;
       span style => "background-image: url('images/$img.png')", '';
       b $sys->[0]{name};
       if(@$sys > 1) {
         my $i = 0;
         for(reverse @$sys) {
           a href => "/pkg/$_->{short}", ++$i > 3 ? (class => 'hidden') : (), $_->{release};
           lit ' ';
         }
         a href => "#", class => 'more', 'more...' if $i > 3;
       }
      end 'a' if @$sys == 1;
     end;
   }
  end;

  h2 'Other sites';
  ul id => 'external';
   li; a href => 'http://man.cx/', 'Man.cx'; end;
   li; a href => 'http://man.he.net/', 'Man.he.net'; end;
   li; a href => 'http://linux.die.net/man/', 'Die.net'; end;
   li; a href => 'http://www.freebsd.org/cgi/man.cgi', 'FreeBSD.org Man Pages'; end;
   li; a href => 'http://www.openbsd.org/cgi-bin/man.cgi', 'OpenBSD Man Pages'; end;
   li; a href => 'http://manpages.ubuntu.com/', 'Ubuntu Manuals'; end;
   li; a href => 'http://www.manpagez.com/', 'Manpagez.com'; txt ' (Mac OS X, has some texinfo documentation as well)'; end;
  end;
  $self->htmlFooter;
}


sub about {
  my $self = shift;
  $self->htmlHeader(title => 'About');
  h1 'About Manned.org';
  div id => 'about';

  h2 'Goal';
  p; lit <<'  _';
   The state of online indices of manual pages is a sad one. Existing sites
   only offer you a single version of a man page: From one origin, and often
   only in a single language. Most don't even tell you where the manual
   actually originated from, making it very hard to determine whether the
   manual you found actually applies to your situation and even harder to find
   a manual from a specific system. Additionally, some sites render the manuals
   in an unreadable way, don't correctly handle special formatting - like
   tables - or don't correctly display non-ASCII characters.
   <br /><br />
   Manned.org was created in order to improve this situation. This site aims to
   index the manual pages from a variaty of systems, both old and new, and
   allows you to browse through the various versions of a manual page to find
   out how each system behaves. The manuals are stored in the database as
   UTF-8, and are passed through <a
   href="http://www.gnu.org/software/groff/">groff</a> to render them in
   (mostly) the same way as they are displayed in your terminal.
  _
  end;

  h2 'The indexing process';
  p; lit <<'  _';
   All man pages are fetched right from the (binary) packages available on the
   public repositories of Linux distributions. In particular:<br />
   <br />
   <dl>
    <dt>Arch Linux</dt><dd>
     The core, extra and community repositories are fetched from a local
     Arch mirror. Indexing started around begin June 2012.</dd>
    <dt>Debian</dt><dd>
     Historical releases were fetched from <a
     href="http://archive.debian.org/debian/">http://archive.debian.org/debian/</a>
     and <a href="http://snapshot.debian.org/">http://snapshot.debian.org/</a>.
     For buzz, rex and bo, only the 'main' component has been indexed, and
     we're missing a few man pages because some packages were missing from the
     repository archives. For the other releases, all components (main, contrib
     and non-free) from the $release and $release-updates (where available)
     repositories are indexed.</dd>
    <dt>FreeBSD</dt><dd>
     Historical releases were fetched from <a
     href="http://ftp-archive.freebsd.org/mirror/FreeBSD-Archive/">http://ftp-archive.freebsd.org/mirror/FreeBSD-Archive/</a>.
     The base installation tarballs are included in the database as packages
     prefixed with <i>core-</i>. The package repositories have also been
     indexed, except for 2.0.5 - 2.2.7 and 3.0 - 3.3 because those were not
     available on the ftp archive. Only the -RELEASE repositories have been
     included, which is generally a snapshot of the ports directory around the
     time of the release. A few packages are missing because the indexing
     script was unable to determine the package name and version for
     everything. Additionally, the dates indicated for many packages is a bit
     off, and the site doesn't handle this very well yet. :-(</dd>
    <dt>Ubuntu</dt><dd>
     Historical releases were fetched from <a
     href="http://old-releases.ubuntu.com/ubuntu/">http://old-releases.ubuntu.com/ubuntu/</a>,
     supported releases from a local mirror.  All components (main, universe,
     restricted and multiverse) from the $release, $release-updates and
     $release-security repositories are indexed.  Backports are not included at
     the moment. Indexing started around mid June 2012.</dd>
   </dl><br />
   Only packages for a single architecture (i386 or i686) are scanned. To my
   knowledge, packages that come with different manuals for different
   architectures either don't exist or are extremely rare. It does happen that
   some packages are not available for all architectures.  Usually, though,
   every package is at least available for i386/i686, so hopefully we're not
   missing out on much.
   <br /><br />
   The repositories are scanned for new packages on a daily basis.
  _
  end;

  h2 'Other systems';
  p; lit <<'  _';
   Although further development of this site is a bit stalled at the moment,
   I'd love to index the manuals of most major Linux distributions in the
   future. Fedora and OpenSUSE, in particular, are interesting targets to
   index.
   <br /><br />
   It would also be great to index a few more non-Linux systems such as other
   BSDs, Solaris/Illumos and Mac OS X. Unfortunately, those don't always follow
   a binary package based approach, or are otherwise less easy to properly
   index.
   <br /><br />
   In general, systems that follow an entirely source-based distribution
   approach can't be indexed without compiling everything. Since that is both
   very resource-heavy and open to security issues, there are no plans to
   include manuals from such systems at the moment. So unless someone comes
   with a solution I hadn't thought of yet, there won't be any Gentoo manuals
   here. :-(
  _
  end;

  h2 'Future plans';
  p; lit <<'  _';
   This site isn't nearly as awesome yet as it could be. Here's some ideas that
   would be nice to have in the future:
   <ul>
    <li>Improved, more intelligent, search,</li>
    <li><a href="/apropos.1">apropos(1)</a> emulation(?),</li>
    <li>Diffs between various versions of a man page,</li>
    <li>Anchor links within man pages, for easier linking to a section or paragraph,</li>
    <li>Table of Contents for each man page,</li>
    <li>Alternative formats (Text, PDF, more semantic HTML, etc),</li>
    <li>A command-line client, like <a href="/man.1">man(1)</a> with manned.org as database backend.</li>
   </ul>
  _
  end;

  h2 'Copyright';
  p; lit <<'  _';
   All manual pages are copyrighted by their respective authors. The manuals
   have been fetched from publically available repositories of free and
   (primarily) open source software. The distributors of said software have put
   in efforts to only include software and documentation that allows free
   distribution. Nonetheless, if a manual that does not allow to be
   redistributed has been inadvertently included in our index, please let me
   know and I will have it removed as soon as possible.
  _
  end;

  end;
  $self->htmlFooter;
}


sub browsesearch {
  my $self = shift;
  my $q = $self->reqGet('q')||'';
  my $man = $self->dbSearch($q, 150);

  return $self->resRedirect("/$man->[0]{name}.$man->[0]{section}", 'temp') if @$man == 1;

  $self->htmlHeader(title => 'Search results for '.$q);
  h1 'Search results for '.$q;
  p 'Note: This is just a simple case-insensitive prefix match on the man names. In the future we\'ll have more powerful search functionality. Hopefully.';
  if(@$man) {
    ul id => 'searchres';
     for(@$man) {
       li;
        a href => "/$_->{name}.$_->{section}", $_->{name};
        i " $_->{section}";
       end;
     }
    end;
  } else {
    br; br;
    b 'No results :-(';
  }

  $self->htmlFooter;
}


sub pkg_list {
  my($self, $short) = @_;

  my $sys = $self->{sysbyshort}{$short};
  return $self->resNotFound if !$sys;

  my $f = $self->formValidate(
    { get => 'c', required => 0, enum => [ '0', 'all', 'a'..'z' ], default => 'all' },
    { get => 's', required => 0, regex => qr/^[a-zA-Z0-9_+.-]+$/i },
  );
  return $self->resNotFound if $f->{_err};

  my $pkg = $self->dbPackageGet(
    hasman => 1,
    sysid => $sys->{id},
    char => $f->{c} eq 'all' ? undef : $f->{c},
    start => $f->{s},
    results => 201,
  );

  my $more = @$pkg > 200 && pop @$pkg;

  # TODO: A "previous" link would be nice...
  my $next = sub {
    use utf8;
    if($more) {
      p class => 'pagination';
       a href => "/pkg/$short?c=$f->{c};s=$pkg->[199]{name}", 'next »';
      end;
    }
  };

  my $title = "Packages for $sys->{name}".($sys->{release}?" $sys->{release}":"");
  $self->htmlHeader(title => $title);
  h1 $title;

  p id => 'charselect';
   for('all', 0, 'a'..'z') {
     a href => "/pkg/$short?c=$_", $_?uc$_:'#' if $_ ne $f->{c};
     b $_?uc$_:'#' if $_ eq $f->{c};
   }
  end;

  p 'Note: Packages without man pages are not listed.';
  $next->();
  ul id => 'packages';
   for(@$pkg) {
     li;
      a href => "/pkg/$short/$_->{category}/$_->{name}", $_->{name};
      i ' '.$_->{category};
     end;
   }
  end;
  $next->();
  $self->htmlFooter;
}


sub pkg_frompath {
  my($self, $sys, $path) = @_;

  # $path should be "$category/$name" or "$category/$name/$version", since
  # $category may contain a slash, let's try both options.

  # $category/$name
  # e.g. contrib/games/alien
  if($path =~ m{^(.+)/([^/]+)$}) {
    my($category, $name) = ($1, $2);
    my $pkg = $self->dbPackageGet(sysid => $sys, category => $category, name => $name, hasman => 1)->[0];
    return ($pkg, '') if $pkg;
  }

  # $category/$name/$version
  # e.g. contrib/games/alien/10.2
  if($path =~ m{^(.+)/([^/]+)/([^/]+)$}) {
    my($category, $name, $version) = ($1, $2, $3);
    my $pkg = $self->dbPackageGet(sysid => $sys, category => $category, name => $name, hasman => 1)->[0];
    return ($pkg, $version) if $pkg;
  }

  (undef, '');
}


sub pkg_info {
  my($self, $short, $path) = @_;

  my $sys = $self->{sysbyshort}{$short};
  return $self->resNotFound if !$sys;

  my($pkg, $ver) = pkg_frompath($self, $sys->{id}, $path);
  return $self->resNotFound if !$pkg;

  my $vers = $self->dbPackageVersions($pkg->{id});

  my $sel = $ver ? (grep $_->{version} eq $ver, @$vers)[0] : $vers->[0];
  return $self->resNotFound if !$sel;

  my $f = $self->formValidate({ get => 's', required => 0});
  return $self->resNotFound if $f->{_err};

  my $mans = $self->dbManInfo(package => $sel->{id}, results => 201, start => $f->{s}, sort => 'name');
  my $more = @$mans > 200 && pop @$mans;

  # Latest version of this package determines last modification date of the page.
  $self->setLastMod($vers->[0]{released});

  my $title = "$sys->{name}".($sys->{release}?" $sys->{release}":"")." / $pkg->{category} / $pkg->{name}";
  $self->htmlHeader(title => "$title $sel->{version}");
  h1 $title;

  div id => 'pkgversions';
   h2 'Versions';
   ul;
    for(@$vers) {
      li;
       a href => "/pkg/$sys->{short}/$pkg->{category}/$pkg->{name}/$_->{version}", $_->{version} if $_ != $sel;
       b " $_->{version}" if $_ == $sel;
       i " $_->{released}";
      end;
    }
   end;
  end;

  div id => 'pkgmans';
  h2 "Manuals for version $sel->{version}";
   ul;
    for(@$mans) {
      li;
       a href => "/$_->{name}/".substr($_->{hash},0,8), "$_->{name}($_->{section})";
       b " $_->{locale}" if $_->{locale};
       i " $_->{filename}";
      end;
    }
   end;
   if($more) {
     use utf8;
     p class => 'pagination';
      a href => "/pkg/$sys->{short}/$pkg->{category}/$pkg->{name}/$sel->{version}?s=$mans->[199]{name}", 'next »';
     end;
   }
  end;

  $self->htmlFooter;
}


sub manjslist {
  my($self, $m) = @_;

  # The structure we generate is described in the JS code.
  my %sys;
  push @{$sys{$_->{system}}}, $_ for (@$m);
  [
    map [ $self->{sysbyid}{$_}{name}, $self->{sysbyid}{$_}{full}, $self->{sysbyid}{$_}{short},
      do {
        my %pkgs;
        for(@{$sys{$_}}) {
          my $pn = "$_->{category}-$_->{package}-$_->{version}";
          $pkgs{$pn} = [ $_->{category}, $_->{package}, $_->{version}, [], $_->{released} ] if !$pkgs{$pn};
          push @{$pkgs{$pn}[3]}, [ $_->{section}, $_->{locale}, substr $_->{hash}, 0, 8 ];
        }
        [ grep
          delete($_->[4]) && ($_->[3] = [sort { $a->[0] cmp $b->[0] || ($a->[1]||'') cmp ($b->[1]||'') } @{$_->[3]}]),
          sort { $a->[0] cmp $b->[0] || $a->[1] cmp $b->[1] || $b->[4] cmp $a->[4] } values %pkgs ];
      }
    ],
    sort { my $x=$self->{sysbyid}{$a}; my $y=$self->{sysbyid}{$b}; $x->{name} cmp $y->{name} or $y->{relorder} <=> $x->{relorder} } keys %sys
  ]
}


# Given the name and optionally the hash of a man page, check with a list of
# man pages with the same name to select the right one for display.
sub getman {
  my($self, $name, $hash) = @_;

  # Fetch all files with $name and split off the section part if $name has one
  my $list = $self->dbManInfo(name => $name);
  my $sect;
  if(!@$list && $name =~ s/\.([^\.]+)$//) {
    $sect = $1;
    $list = $self->dbManInfo(name => $name);
  }
  return (undef, undef) if !@$list;

  # If we already have a shorthash, just get the full hash
  if($hash) {
    $_->{hash} =~ /^$hash/ && return ($_, $list) for (@$list);
  }

  # If that failed, use some heuristics
  my $cmp = sub {
    local($a,$b) = @_;
    # English or non-locale packages always win
    !(($a->{locale}||'') =~ /^(en|$)/) != !(($b->{locale}||'') =~ /^(en|$)/)
      ? (($a->{locale}||'') =~ /^(en|$)/ ? -1 : 1)
    # Newer versions of a package have higher priority
    : $a->{system} == $b->{system} && $a->{package} eq $b->{package} && $a->{version} ne $b->{version}
      ? $b->{released} cmp $a->{released}
    # Section prefix match.
    : $sect && !($a->{section} =~ /^\Q$sect/) != !($b->{section} =~ /^\Q$sect/)
      ? ($a->{section} =~ /^\Q$sect/ ? -1 : 1)
    # Give lower priority to pages in a non-standard directory
    : !($a->{filename} =~ q{^/usr/share/man}) != !($b->{filename} =~ q{^/usr/share/man})
      ? ($a->{filename} =~ q{^/usr/share/man} ? -1 : 1)
    # Prefer Arch over other systems
    : ($a->{system} != 1 || $b->{system} != 1) && $self->{sysbyid}{$a->{system}}{name} ne $self->{sysbyid}{$b->{system}}{name}
      ? ($a->{system} == 1 ? -1 : 1)
    # Prefer a later system release over an older one
    : $a->{system} != $b->{system} && $self->{sysbyid}{$a->{system}}{name} eq $self->{sysbyid}{$b->{system}}{name}
      ? $self->{sysbyid}{$b->{system}}{relorder} <=> $self->{sysbyid}{$a->{system}}{relorder}
    # Lower sections > higher sections (because 'man' does this as well)
    : substr($a->{section},0,1) ne substr($b->{section},0,1)
      ? $a->{section} cmp $b->{section}
    # Sections without appendix before sections with appendix
    : $a->{section} ne $b->{section}
      ? $a->{section} cmp $b->{section}
    # Fallback to hash if nothing else matters (guarantees the order is at least stable)
    : $a->{hash} cmp $b->{hash};
  };

  my $winner = $list->[0];
  $cmp->($winner, $_) > 0 and ($winner = $_) for (@$list);
  ($winner, $list);
}


sub man {
  my($self, $name, $hash) = @_;

  # Firefox seems to escape [ and ] in URLs. It doesn't really have to...
  $name =~ s/%5b/[/ig;
  $name =~ s/%5d/]/ig;

  my($man, $m) = getman($self, $name, $hash);
  return $self->resNotFound() if !$man;

  my $view = $self->formValidate({get => 'v', regex => qr/^[a-z2-7]+$/});
  $view = $view->{_err} ? '' : $view->{v};

  # To be really correct, the last modification time of this page should be the
  # release date of the latest version of the man page, as that is displayed in
  # the menu. But let's just consider the content of the page as more
  # important, and use release date of the man page as last modification date.
  $self->setLastMod($man->{released});

  $self->htmlHeader(title => $name);
  div id => 'nav', 'Sorry, this navigation menu won\'t display without Javascript. :-(';

  h1;
   txt $man->{name}.' ';
   a href => "/$man->{name}/".substr($man->{hash}, 0, 8).'/src', 'source';
  end;

  div id => 'contents';
   my $c = $self->dbManContent($man->{hash});
   # TODO: Store/cache the result of fmt() in the database.
   pre; lit ManUtils::html(ManUtils::fmt_block $c); end;
  end;

  div id => 'locations';
   h2 'Locations of this man page';
   table;
    thead; Tr;
     td 'System';
     td 'Package';
     td 'Version';
     td 'Name';
     td 'Filename';
    end; end;
    my @l = sort {
         $self->{sysbyid}{$a->{system}}{name}     cmp $self->{sysbyid}{$b->{system}}{name}
      || $self->{sysbyid}{$b->{system}}{relorder} <=> $self->{sysbyid}{$a->{system}}{relorder}
      || $b->{released} cmp $a->{released}
      || $a->{filename} cmp $b->{filename}
    } @{$self->dbManInfo(hash => $man->{hash})};
    for(@l) {
      Tr;
       td $self->{sysbyid}{$_->{system}}{full};
       td "$_->{category}/$_->{package}";
       td $_->{version};
       td;
        a href => "/$_->{name}", $_->{name} if $_->{name} ne $man->{name};
        txt $_->{name} if $_->{name} eq $man->{name};
        txt ".$_->{section}";
       end;
       td $_->{filename};
      end;
    }
   end;
  end;

  $self->htmlFooter(js => { hash => substr($man->{hash}, 0, 8), name => $man->{name}, view => $view, mans => manjslist($self, $m) });
}


sub src {
  my($self, $name, $hash) = @_;

  my $m = $self->dbManInfo(name => $name, shorthash => $hash);
  return $self->resNotFound if !@$m;

  $self->setLastMod($m->[0]{released});
  $self->resHeader('Content-Type', 'text/plain; charset=UTF-8');
  $self->resHeader('Content-Disposition', sprintf 'filename="%s.%s"', $m->[0]{name}, $m->[0]{section});
  my $c = $self->dbManContent($m->[0]{hash});
  lit $c;
}


sub xmlsearch {
  my $self = shift;
  my $q = $self->reqGet('q')||'';
  my $man = $self->dbSearch($q, 20);

  # The JS dropdown search expects this particular format.
  $self->resHeader('Content-Type' => 'text/xml; charset=UTF-8');
  xml;
  tag 'results';
   tag 'item', id => "$_->{name}.$_->{section}", %$_, undef for(@$man);
  end 'results';
}



package TUWF::Object;

use TUWF ':html', 'html_escape';
use Time::Local 'timegm';

sub htmlHeader {
  my $self = shift;
  my %o = @_;

  html;
   head;
    Link rel => 'stylesheet', type => 'text/css', href => '/man.css?2';
    title $o{title}.' - manned.org';
   end 'head';
   body;

    div id => 'header';
     a href => '/', 'manned.org';
     form action => '/browse/search', method => 'get';
      input type => 'text', name => 'q', id => 'q', tabindex => 1;
      input type => 'submit', value => ' ';
     end;
    end;

    div id => 'body';
}


sub htmlFooter {
  my($self, %o) = @_;

     br style => 'clear: both';
    end;
    div id => 'footer';
     lit 'All manual pages are copyrighted by their respective authors.
       | <a href="/info/about">About manned.org</a>
       | <a href="mailto:contact@manned.org">Contact</a>
       | <a href="https://g.blicky.net/manned.git/">Source</a>';
    end;
    if($o{js}) {
      script type => 'text/javascript';
       lit 'VARS = ';
       lit(JSON::XS->new->ascii->encode($o{js}));
       lit ';';
      end;
    }
    script type => 'text/javascript', src => '/man.js', '';
   end;
  end 'html';

  # write the SQL queries as a HTML comment when debugging is enabled
  # (stolen from VNDB code)
  if($self->debug) {
    lit "\n<!--\n SQL Queries:\n";
    for (@{$self->{_TUWF}{DB}{queries}}) {
      my $q = !ref $_->[0] ? $_->[0] :
        $_->[0][0].(exists $_->[0][1] ? ' | "'.join('", "', map defined()?$_:'NULL', @{$_->[0]}[1..$#{$_->[0]}]).'"' : '');
      $q =~ s/^\s//g;
      lit sprintf "  [%6.2fms] %s\n", $_->[1]*1000, $q;
    }
    lit "-->\n";
  }
}


# Set the last modification time from a string in yyyy-mm-dd format.
sub setLastMod {
  my($s, $d) = @_;
  return if $d !~ /^(\d{4})-(\d{2})-(\d{2})/;
  my @t = gmtime timegm 0,0,0,$3,$2-1,$1;
  $s->resHeader('Last-Modified', sprintf '%s, %02d %s %04d %02d:%02d:%02d GMT',
    (qw|Sun Mon Tue Wed Thu Fri Sat|)[$t[6]], $t[3],
    (qw|Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec|)[$t[4]],
    $t[5]+1900, $t[2], $t[1], $t[0]);
}


sub dbManContent {
  my($s, $hash) = @_;
  return $s->dbRow(q{SELECT content FROM contents WHERE hash = decode(?, 'hex')}, $hash)->{content};
}


# Options: name, section, shorthash, package, start, results, sort
sub dbManInfo {
  my $s = shift;
  my %o = @_;

  my %where = (
    $o{name}      ? ('m.name = ?'    => $o{name}) : (),
    $o{package}   ? ('m.package = ?' => $o{package}) : (),
    $o{section}   ? ('m.section = ?' => $o{section}) : (),
    $o{shorthash} ? (q{substring(m.hash from 1 for 4) = decode(?, 'hex')} => $o{shorthash}) : (),
    $o{hash}      ? (q{m.hash = decode(?, 'hex')} => $o{hash}) : (),
    $o{start}     ? ('m.name > ?' => $o{start}) : (),
  );

  # TODO: Flags to indicate what to information to fetch
  return $s->dbAll(q{
    SELECT p.system, p.category, p.name AS package, pv.version, pv.released, m.name, m.section, m.filename, m.locale, encode(m.hash, 'hex') AS hash
      FROM packages p
      JOIN package_versions pv ON p.id = pv.package
      JOIN man m ON m.package = pv.id
        !W
        !s
     LIMIT ?
  },
    \%where,
    $o{sort} ? 'ORDER BY name' : '',
    $o{results}||10000
  );
}


# Very simple (and fast) prefix match.
sub dbSearch {
  my($s, $q, $limit) = @_;

  my $sect = $q =~ s/^([0-9])\s+// || $q =~ s/\(([a-zA-Z0-9]+)\)$// ? $1 : '';
  my $name = $q =~ s/^([a-zA-Z0-9,.:_-]+)// ? $1 : '';

  return !$name ? [] : $s->dbAll(
    'SELECT name, section FROM man_index !W ORDER BY name, section LIMIT ?',
    { # Don't use wildcards in this query, prevents index usage.
      "lower(name) LIKE '\L$name\E%'" => 1,
      $sect ? ("section ILIKE '\L$sect\E%'" => 1) : ()
    },
    $limit
  );
}


sub dbSystemGet {
  return shift->dbAll('SELECT id, name, release, short, relorder FROM systems ORDER BY name, relorder');
}


# Options: sysid char hasman start results
sub dbPackageGet {
  my $s = shift;
  my %o = (results => 10, @_);

  my @where = (
    $o{sysid} ? ('system = ?' => $o{sysid}) : (),
    $o{category} ? ('category = ?' => $o{category}) : (),
    $o{name} ? ('name = ?' => $o{name}) : (),
    $o{start} ? ('name > ?' => $o{start}) : (),
    # This seems slow, perhaps cache?
    defined($o{hasman}) ? ('!s EXISTS(SELECT 1 FROM package_versions pv WHERE pv.package = p.id AND EXISTS(SELECT 1 FROM man m WHERE m.package = pv.id))' => $o{hasman}?'':'NOT') : (),
    $o{char} ? ( 'LOWER(SUBSTR(name, 1, 1)) = ?' => $o{char} ) : (),
    defined($o{char}) && !$o{char} ? ( '(ASCII(name) < 97 OR ASCII(name) > 122) AND (ASCII(name) < 65 OR ASCII(name) > 90)' => 1 ) : (),
  );

  return $s->dbAll(q{
      SELECT id, system, name, category
        FROM packages p
          !W
    ORDER BY name
       LIMIT ?},
  \@where, $o{results})
}


sub dbPackageVersions {
  my($s, $id) = @_;

  return $s->dbAll(q{
      SELECT id, version, released
        FROM package_versions v
       WHERE package = ?
         AND EXISTS(SELECT 1 FROM man m WHERE m.package = v.id)
    ORDER BY released DESC},
  $id)
}


sub dbStats {
  return $_[0]->dbRow('SELECT * FROM stats_cache');
}