#!/usr/local/bin/perl 
use POE qw(XS::Queue::Array);
use lib qw(/Users/perigrin/dev/work/Cur/trunk/lib);
{

    package Bullwinkle::Reports;
    use Moose;
    use Template;

    has report_dir => (
        isa     => 'Str',
        is      => 'ro',
        default => sub { '/Users/perigrin/dev/moose/status/reports', },
    );

    has reports_by_date => (
        isa        => 'HashRef',
        is         => 'ro',
        lazy_build => 1,
    );

    has template_config => (
        isa     => 'HashRef',
        is      => 'ro',
        default => sub {
            { INCLUDE_PATH => '/Users/perigrin/dev/moose/status/templates', };
        },
    );

    sub _build_reports_by_date {
        my %results;
        my $report_dir = $_[0]->report_dir;
        foreach ( glob "$report_dir/*" ) {
            my ( $module, $date ) = $_ =~ m{reports/([\w-]+)-results-(.*)\.txt};
            $results{$module}{$date} = load_report($_);
        }
        return \%results;
    }

    sub load_report {
        my $file = shift;

        die 'No input file specified'  unless $file;
        die "That file doesn't exist"  unless -e $file;
        die "That isn't a plain file"  unless -f _;
        die "That file isn't readable" unless -r _;

        open( my $RESULTS, '<', $file ) or die "Can't open $file: $!";
        my @lines = <$RESULTS>;
        close $RESULTS;

        my ( %tests, $current_test );

    # XXX: Test files get added, removed, renamed, etc. A mechanism is necessary
    # here to cope with this.

        foreach (@lines) {
            chomp;

            if (m{^t/(.*?)\.}) {
                $current_test = $1;
            }
            elsif (/^ok$/) {
                $tests{$current_test} = 100;
            }
            elsif (/^Result: PASS$/) {
                $tests{$current_test} = 100;
            }
            elsif (/Failed .*? tests, (.*?)% okay/) {
                $tests{$current_test} = $1;
            }
        }

        \%tests;
    }

    x sub handler {
        my ($self) = @_;

        my %report_data = (
            'results'    => $self->reports_by_name,
            'test_dates' => [ sort keys %{ $self->reports_by_date } ],
        );

        my $tt = Template->new( $self->template_config );
        my $output;
        $tt->process( 'tests.tt', { 'data' => \%report_data }, \$output )
          or $output = $tt->error;
        $self->clear_reports;
        return $output;
    }
    no Moose;
}

package Bullwinkle::Runner;
use Moose;
use Cur;

with qw(MooseX::Getopt);

has apps => (
    isa        => 'ArrayRef[Cur]',
    is         => 'ro',
    lazy_build => 1,
    auto_deref => 1,
);

has handlers => (
    isa        => 'HashRef',
    is         => 'ro',
    auto_deref => 1,
    lazy_build => 1,
    builder    => 'default_handlers',
);

sub _build_apps {
    my @apps;
    my $address = '127.0.0.1';
    for my $port ( 1700 ... 1703 ) {
        my $app = Cur->new( address => $address, port => $port );
        $app->server->register_handler( $_[0]->handlers );
        push @apps, $app;
    }
    return \@apps;
}

sub default_handlers {
    return { '/' => Bullwinkle::Reports->new(), };
}

sub run {
    my ($self) = @_;
    $_->run for $self->apps;
}

no Moose;

__PACKAGE__->new_with_options()->run();

__END__