#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;
use Festival::Client;
use File::Spec;
use HTTP::Cookies;
use HTTP::Request::Common qw{POST};
use LWP;
use XML::Simple;

$| = 1;

# Information for Festival server to connect to
#   (undef as port value to use default port)
my %festival_server = (
    host => q{localhost},
    port => undef,
);

# The following values are in seconds.
# $delay - approximate delay between Message Inbox XML Ticker retrievals
my $delay        = 90;

# $seen - holds message id of last message seen
my $seen = 0;

# Setup
my $username = '(your username here)';
my $password = '(your password here)';

my $xs         = new XML::Simple;
my $cookie_jar =
  File::Spec->catfile( File::Spec->tmpdir(),
    join ( q{.}, ( File::Spec->splitpath($0) )[2] ) . q{.cj} );
my $pm_server = q{www.perlmonks.com};
my $pm_port   = 80;
my $pm_base   = q{http://}
  . $pm_server
  . ( $pm_port != 80 ? q{:} . $pm_port : '' ) . q{/};
my $li_xml_url = $pm_base
  . q{/index.pl?node_id=109;displaytype=xml;xmlstyle=flat;nofields=1;op=login;ticker=1;user=}
  . $username
  . q{;passwd=}
  . $password;
my $last_mi    = 0;
my $max_recs   = 20;
my $mi_xml_url =
  sprintf(
q{%sindex.pl?node_id=%d;archived=%s;xmlstyle=%s;max_recs=%d;since_id=%%d},
    $pm_base, 15848, q{both}, q{default}, $max_recs );

my ($fs);
my ($browser);
my ($ref);
my ($combined_mi);

# Attempt to log in
$browser = LWP::UserAgent->new;
$browser->cookie_jar(
    HTTP::Cookies->new( file => $cookie_jar, autosave => 1 ) );

my $li_xml = $browser->get($li_xml_url)
  or die (
    scalar localtime() . q{: }
      . qq{Could not log into the site: $!\n} );

$ref =
  $xs->XMLin( $li_xml->content, ForceArray => [q{loggedin}] )
  or die (
    scalar localtime() . q{: }
      . qq{Could not parse information regarding login to site XML: $!\n}
  );

# Do not proceed if we did not successfully log in
die (
    scalar localtime() . q{: }
      . qq{Could not log into PM: $!\n} )
  unless ( exists( $ref->{loggedin} ) );

my $count = 10_000
  ; # There should NEVER be more than this number messages, at worst
while ($count) {

    my $mi_xml =
      $browser->get( sprintf( $mi_xml_url, $last_mi ) )
      or warn(
        scalar localtime() . q{: }
          . qq{Could not retrieve Message Inbox XML ticker: $!\n}
      );

    $ref =
      $xs->XMLin( $mi_xml->content, ForceArray => [q{message}] )
      or die (
        scalar localtime() . q{: }
          . qq{Could not parse Message Inbox XML: $!\n} );

    if ( !exists( $combined_mi->{INFO} ) ) {
        $combined_mi->{INFO} = $ref->{INFO};
    }

    $delay = $ref->{INFO}->{min_poll_seconds};
    print qq{Delay: $delay\n};

    # Check to see if there are message entries
    last unless ( exists( $ref->{message} ) );

    foreach my $message ( @{ $ref->{message} } ) {
        push ( @{ $combined_mi->{message} }, $message );
        if ( $message->{message_id} > $seen ) {
            $seen = $message->{message_id};

            printf(
                "%s-%s-%s %s:%s:%s - %s: %s\n",
                substr( $message->{time}, 0,  4 ),
                substr( $message->{time}, 4,  2 ),
                substr( $message->{time}, 6,  2 ),
                substr( $message->{time}, 8,  2 ),
                substr( $message->{time}, 10, 2 ),
                substr( $message->{time}, 12, 2 ),
                $message->{author},
                $message->{content}
            );
            $last_mi = $message->{message_id}
              if ( $message->{message_id} > $last_mi );
        }
    }

    print scalar localtime(), q{: },
      qq{Asked for $max_recs, retrieved },
      scalar @{ $ref->{message} }, qq{\n};
    last if ( scalar @{ $ref->{message} } != $max_recs );

    print qq{Last message id: $last_mi\n};
    print qq{Sleeping for $delay seconds...\n};
    sleep($delay);
}

my ($OUTF);
open( $OUTF, q{>} . $0 . q{.3.out} ) or die (qq{$! \n});
$xs->XMLout(
    $combined_mi,
    (
        AttrIndent => 1,
        KeepRoot   => 1,
        NoEscape   => 1,
        OutputFile => $OUTF,
        RootName   => q{CHATTER},
        XMLDecl    => 1
    )
);
close($OUTF);