package HomePanel::Driver;
use Moo;
use v5.36;
use IO::Async::Loop;
use IO::Async::Timer::Periodic;
use Net::Async::HTTP;
use Future::AsyncAwait;
use WebService::ForecastIo;
use WebService::TFL::Bus;
use WebService::TFL::Bus::Response;
use WebService::TFL::TubeStatus;
use HomePanel::Render;
use Types::Path::Tiny qw(AbsFile AbsPath);
use Types::Standard qw(ArrayRef Str StrictNum);
use Try::Tiny;
use curry::weak;
use namespace::clean;
use Data::Dumper;
has loop => ( is => 'lazy' );
sub _build_loop { IO::Async::Loop->new() }
has user_agent => ( is => 'lazy' );
sub _build_user_agent {
my ($self) = @_;
my $ua = Net::Async::HTTP->new(
max_connections_per_host => 1,
stall_timeout => 10,
decode_content => 1,
);
$self->loop->add($ua);
return $ua;
}
has [qw(forecast_latitude forecast_longitude)] => (
isa => StrictNum,
is => 'ro',
required => 1,
);
has forecast_key => (
isa => Str,
is => 'ro',
required => 1,
);
has forecast => ( is => 'lazy' );
sub _build_forecast {
my ($self) = @_;
WebService::ForecastIo->new({
api_key => $self->forecast_key,
user_agent => $self->user_agent,
});
}
has forecast_response => ( is => 'rw' );
has forecast_timer => ( is => 'lazy' );
sub _build_forecast_timer {
my ($self) = @_;
$self->_new_timer(
900,
$self->curry::weak::forecast_timer_cb(),
);
}
sub forecast_timer_cb {
my ($self) = @_;
$self->forecast->request({
latitude => $self->forecast_latitude,
longitude => $self->forecast_longitude,
exclude => ['flags','sources'],
})->then(sub { $self->forecast_response(shift) })->retain;
}
has bus_stop_ids => (
is => 'ro',
required => 1,
isa => ArrayRef->of(Str)->plus_coercions(Str, sub { [ $_ ] }),
coerce => 1,
);
has bus => (
is => 'lazy',
);
sub _build_bus {
WebService::TFL::Bus->new({
user_agent => $_[0]->user_agent,
});
}
has bus_response => ( is => 'rw' );
has bus_timer => ( is => 'lazy' );
sub _build_bus_timer {
my ($self) = @_;
$self->_new_timer(
30,
$self->curry::weak::bus_timer_cb(),
);
}
sub bus_timer_cb {
my ($self) = @_;
Future->wait_all(
map { $self->bus->request($_) } $self->bus_stop_ids->@*
)->then(
sub {
my @done_results = map { $_->result } grep { $_->is_done } @_;
$self->bus_response(
WebService::TFL::Bus::Response->new_merged(@done_results)
);
}
)->retain;
};
has tube => (
is => 'lazy',
);
sub _build_tube {
WebService::TFL::TubeStatus->new({
user_agent => $_[0]->user_agent,
});
}
has tube_response => ( is => 'rw' );
has tube_timer => ( is => 'lazy' );
sub _build_tube_timer {
my ($self) = @_;
$self->_new_timer(
300,
$self->curry::weak::tube_timer_cb(),
);
}
sub tube_timer_cb {
my ($self) = @_;
$self->tube->request(
)->then(sub { $self->tube_response(shift) })->retain;
}
has writer_timer => ( is => 'lazy' );
sub _build_writer_timer {
my ($self) = @_;
$self->_new_timer(
5,
$self->curry::weak::write_page,
);
}
sub _new_timer {
my ($self,$interval,$code) = @_;
my $timer = IO::Async::Timer::Periodic->new(
interval => $interval,
first_interval => 0,
on_tick => sub {
try { $code->(); } catch { warn "Problem: $_; ignoring" }
},
reschedule => 'drift',
);
$self->loop->add($timer);
return $timer;
}
has template_file => (
is => 'ro',
isa => AbsFile,
coerce => AbsFile->coercion,
required => 1,
);
has output_file => (
is => 'ro',
isa => AbsPath,
coerce => AbsPath->coercion,
required => 1,
);
has render => (
is => 'lazy',
);
sub _build_render {
return HomePanel::Render->new({
template_file => $_[0]->template_file,
});
}
sub write_page {
my ($self) = @_;
return unless $self->forecast_response;
my $output = $self->render->render({
forecast => $self->forecast_response,
bus => $self->bus_response,
tube => $self->tube_response,
});
$self->output_file->spew_utf8($output);
}
sub start {
my ($self) = @_;
$self->forecast_timer->start;
$self->bus_timer->start;
$self->tube_timer->start;
$self->writer_timer->start;
}
1;
