package DBInfoscreen::Controller::Map;

use Mojo::Base 'Mojolicious::Controller';
use Mojo::JSON qw(decode_json);
use Mojo::Promise;

use DateTime;
use DateTime::Format::Strptime;
use Geo::Distance;
use List::Util qw();

my $dbf_version = qx{git describe --dirty} || 'experimental';

my $strp = DateTime::Format::Strptime->new(
	pattern   => '%Y-%m-%dT%H:%M:%S.000%z',
	time_zone => 'Europe/Berlin',
);

chomp $dbf_version;

sub get_route_indexes {
	my ( $features, $from_name, $to_name ) = @_;
	my ( $from_index, $to_index );

	for my $i ( 0 .. $#{$features} ) {
		my $this_point = $features->[$i];
		if (    not defined $from_index
			and $this_point->{properties}{type}
			and $this_point->{properties}{type} eq 'stop'
			and $this_point->{properties}{name} eq $from_name )
		{
			$from_index = $i;
		}
		elsif ( $this_point->{properties}{type}
			and $this_point->{properties}{type} eq 'stop'
			and $this_point->{properties}{name} eq $to_name )
		{
			$to_index = $i;
			last;
		}
	}
	return ( $from_index, $to_index );
}

# Returns timestamped train positions between stop1 and stop2 (must not have
# intermittent stops) in 10-second steps.
sub estimate_timestamped_positions {
	my (%opt) = @_;

	my $from_dt   = $opt{from}{dep};
	my $to_dt     = $opt{to}{arr};
	my $from_name = $opt{from}{name};
	my $to_name   = $opt{to}{name};
	my $features  = $opt{features};

	my $duration = $to_dt->epoch - $from_dt->epoch;

	my @train_positions;

	my @completion_ratios
	  = map { ( $_ * 10 / $duration ) } ( 0 .. $duration / 10 );

	my ( $from_index, $to_index )
	  = get_route_indexes( $features, $from_name, $to_name );

	my $location_epoch = $from_dt->epoch;
	my $geo            = Geo::Distance->new;

	if ( defined $from_index and defined $to_index ) {
		my $total_distance = 0;
		for my $j ( $from_index + 1 .. $to_index ) {
			my $prev = $features->[ $j - 1 ]{geometry}{coordinates};
			my $this = $features->[$j]{geometry}{coordinates};
			if ( $prev and $this ) {
				$total_distance += $geo->distance(
					'kilometer', $prev->[0], $prev->[1],
					$this->[0],  $this->[1]
				);
			}
		}
		my @marker_distances = map { $total_distance * $_ } @completion_ratios;
		$total_distance = 0;
		for my $j ( $from_index + 1 .. $to_index ) {
			my $prev = $features->[ $j - 1 ]{geometry}{coordinates};
			my $this = $features->[$j]{geometry}{coordinates};
			if ( $prev and $this ) {
				my $prev_distance = $total_distance;
				$total_distance += $geo->distance(
					'kilometer', $prev->[0], $prev->[1],
					$this->[0],  $this->[1]
				);
				for my $i ( @train_positions .. $#marker_distances ) {
					my $marker_distance = $marker_distances[$i];
					if ( $total_distance > $marker_distance ) {

						# completion ratio for the line between (prev, this)
						my $sub_ratio = 1;
						if ( $total_distance != $prev_distance ) {
							$sub_ratio = ( $marker_distance - $prev_distance )
							  / ( $total_distance - $prev_distance );
						}

						my $lat = $prev->[1]
						  + ( $this->[1] - $prev->[1] ) * $sub_ratio;
						my $lon = $prev->[0]
						  + ( $this->[0] - $prev->[0] ) * $sub_ratio;

						push( @train_positions,
							[ $location_epoch, $lat, $lon ] );
						$location_epoch += 10;
					}
				}
				if ( @train_positions == @completion_ratios ) {
					return @train_positions;
				}
			}
		}
		if (@train_positions) {
			return @train_positions;
		}
	}
	return;
}

# Input:
#   now: DateTime
#   from: current/previous stop
#         {dep => DateTime, name => str, lat => float, lon => float}
#   to: next stop
#       {arr => DateTime, name => str, lat => float, lon => float}
#   features: https://github.com/public-transport/hafas-client/blob/4/docs/trip.md features array
# Output: list of estimated train positions in [lat, lon] format.
# - current position
# - position 2 seconds from now
# - position 4 seconds from now
# - ...
sub estimate_train_positions {
	my (%opt) = @_;

	my $now = $opt{now};

	my $from_dt   = $opt{from}{dep};
	my $to_dt     = $opt{to}{arr};
	my $from_name = $opt{from}{name};
	my $to_name   = $opt{to}{name};
	my $features  = $opt{features};

	my @train_positions;

	my $time_complete = $now->epoch - $from_dt->epoch;
	my $time_total    = $to_dt->epoch - $from_dt->epoch;

	my @completion_ratios
	  = map { ( $time_complete + ( $_ * 2 ) ) / $time_total } ( 0 .. 45 );

	my $geo = Geo::Distance->new;

	my ( $from_index, $to_index )
	  = get_route_indexes( $features, $from_name, $to_name );

	if ( defined $from_index and defined $to_index ) {
		my $total_distance = 0;
		for my $j ( $from_index + 1 .. $to_index ) {
			my $prev = $features->[ $j - 1 ]{geometry}{coordinates};
			my $this = $features->[$j]{geometry}{coordinates};
			if ( $prev and $this ) {
				$total_distance += $geo->distance(
					'kilometer', $prev->[0], $prev->[1],
					$this->[0],  $this->[1]
				);
			}
		}
		my @marker_distances = map { $total_distance * $_ } @completion_ratios;
		$total_distance = 0;
		for my $j ( $from_index + 1 .. $to_index ) {
			my $prev = $features->[ $j - 1 ]{geometry}{coordinates};
			my $this = $features->[$j]{geometry}{coordinates};
			if ( $prev and $this ) {
				my $prev_distance = $total_distance;
				$total_distance += $geo->distance(
					'kilometer', $prev->[0], $prev->[1],
					$this->[0],  $this->[1]
				);
				for my $i ( @train_positions .. $#marker_distances ) {
					my $marker_distance = $marker_distances[$i];
					if ( $total_distance > $marker_distance ) {

						# completion ratio for the line between (prev, this)
						my $sub_ratio = 1;
						if ( $total_distance != $prev_distance ) {
							$sub_ratio = ( $marker_distance - $prev_distance )
							  / ( $total_distance - $prev_distance );
						}

						my $lat = $prev->[1]
						  + ( $this->[1] - $prev->[1] ) * $sub_ratio;
						my $lon = $prev->[0]
						  + ( $this->[0] - $prev->[0] ) * $sub_ratio;

						push( @train_positions, [ $lat, $lon ] );
					}
				}
				if ( @train_positions == @completion_ratios ) {
					return @train_positions;
				}
			}
		}
		if (@train_positions) {
			return @train_positions;
		}
	}
	else {
		for my $ratio (@completion_ratios) {
			my $lat
			  = $opt{from}{lat} + ( $opt{to}{lat} - $opt{from}{lat} ) * $ratio;
			my $lon
			  = $opt{from}{lon} + ( $opt{to}{lon} - $opt{from}{lon} ) * $ratio;
			push( @train_positions, [ $lat, $lon ] );
		}
		return @train_positions;
	}
	return [ $opt{to}{lat}, $opt{to}{lon} ];
}

# Input:
#   now: DateTime
#   route: hash
#     lat: float
#     lon: float
#     name: str
#     arr: DateTime
#     dep: DateTime
#   features: ref to transport.rest features list
#  Output:
#    next_stop: {type, station}
#    positions: [current position [lat, lon], 2s from now, 4s from now, ...]
sub estimate_train_positions2 {
	my (%opt) = @_;
	my $now   = $opt{now};
	my @route = @{ $opt{route} // [] };

	my @train_positions;
	my $next_stop;

	for my $i ( 1 .. $#route ) {
		if (    $route[$i]{arr}
			and $route[ $i - 1 ]{dep}
			and $now > $route[ $i - 1 ]{dep}
			and $now < $route[$i]{arr} )
		{

			# (current position, future positons...) in 2 second steps
			@train_positions = estimate_train_positions(
				from     => $route[ $i - 1 ],
				to       => $route[$i],
				now      => $now,
				features => $opt{features},
			);

			$next_stop = {
				type    => 'next',
				station => $route[$i],
			};
			last;
		}
		if ( $route[ $i - 1 ]{dep} and $now <= $route[ $i - 1 ]{dep} ) {
			@train_positions
			  = ( [ $route[ $i - 1 ]{lat}, $route[ $i - 1 ]{lon} ] );
			$next_stop = {
				type    => 'present',
				station => $route[ $i - 1 ],
			};
			last;
		}
	}

	if ( not $next_stop ) {
		@train_positions = ( [ $route[-1]{lat}, $route[-1]{lon} ] );
		$next_stop       = {
			type    => 'present',
			station => $route[-1]
		};
	}

	my $position_now = shift @train_positions;

	return {
		next_stop    => $next_stop,
		position_now => $position_now,
		positions    => \@train_positions,
	};
}

sub estimate_train_intersection {
	my (%opt) = @_;
	my @route1 = @{ $opt{routes}[0] // [] };
	my @route2 = @{ $opt{routes}[1] // [] };

	my $ret;

	my $i1 = 0;
	my $i2 = 0;

	my @pairs;
	my @meeting_points;
	my $geo = Geo::Distance->new;

	# skip last route element as we compare route[i] with route[i+1]
	while ( $i1 < $#route1 and $i2 < $#route2 ) {
		my $dep1 = $route1[$i1]{dep};
		my $arr1 = $route1[ $i1 + 1 ]{arr};
		my $dep2 = $route2[$i2]{dep};
		my $arr2 = $route2[ $i2 + 1 ]{arr};

		if ( not( $dep1 and $arr1 ) ) {
			say "skip 1 $route1[$i1]{name}";
			$i1++;
			next;
		}

		if ( not( $dep2 and $arr2 ) ) {
			say "skip 2 $route2[$i2]{name}";
			$i2++;
			next;
		}

		if ( $arr1 <= $dep2 ) {
			$i1++;
		}
		elsif ( $arr2 <= $dep1 ) {
			$i2++;
		}
		elsif ( $arr2 <= $arr1 ) {
			push( @pairs, [ $i1, $i2 ] );
			if (    $route1[$i1]{name} eq $route2[ $i2 + 1 ]{name}
				and $route2[$i2]{name} eq $route1[ $i1 + 1 ]{name} )
			{
              # both i1 name == i2+1 name and i1 name == i2 name are valid cases
              # (trains don't just intersect when they travel in opposing
              # directions -- they may also travel in the same direction
              # with different speed and overtake each other).
              # We need both stop pairs later on, so we save both.
				$ret->{stop_pair} = [
					[ $route1[$i1]{name}, $route1[ $i1 + 1 ]{name} ],
					[ $route2[$i2]{name}, $route2[ $i2 + 1 ]{name} ]
				];
			}
			$i2++;
		}
		elsif ( $arr1 <= $arr2 ) {
			push( @pairs, [ $i1, $i2 ] );
			if (    $route1[$i1]{name} eq $route2[ $i2 + 1 ]{name}
				and $route2[$i2]{name} eq $route1[ $i1 + 1 ]{name} )
			{
				$ret->{stop_pair} = [
					[ $route1[$i1]{name}, $route1[ $i1 + 1 ]{name} ],
					[ $route2[$i2]{name}, $route2[ $i2 + 1 ]{name} ]
				];
			}
			$i1++;
		}
		else {
			$i1++;
		}
	}

	for my $pair (@pairs) {
		my ( $i1, $i2 ) = @{$pair};
		my @train1_positions = estimate_timestamped_positions(
			from     => $route1[$i1],
			to       => $route1[ $i1 + 1 ],
			features => $opt{features}[0],
		);
		my @train2_positions = estimate_timestamped_positions(
			from     => $route2[$i2],
			to       => $route2[ $i2 + 1 ],
			features => $opt{features}[1],
		);
		$i1 = 0;
		$i2 = 0;
		while ( $i1 <= $#train1_positions and $i2 <= $#train2_positions ) {
			if ( $train1_positions[$i1][0] < $train2_positions[$i2][0] ) {
				$i1++;
			}
			elsif ( $train1_positions[$i2][0] < $train2_positions[$i2][0] ) {
				$i2++;
			}
			else {
				if (
					(
						my $distance = $geo->distance(
							'kilometer',
							$train1_positions[$i1][2],
							$train1_positions[$i1][1],
							$train2_positions[$i2][2],
							$train2_positions[$i2][1]
						)
					) < 1
				  )
				{
					my $ts = DateTime->from_epoch(
						epoch     => $train1_positions[$i1][0],
						time_zone => 'Europe/Berlin'
					);
					$ret->{first_meeting_time} //= $ts;
					push(
						@meeting_points,
						{
							timestamp => $ts,
							lat       => (
								    $train1_positions[$i1][1]
								  + $train2_positions[$i2][1]
							) / 2,
							lon => (
								    $train1_positions[$i1][2]
								  + $train2_positions[$i2][2]
							) / 2,
							distance => $distance,
						}
					);
				}
				$i1++;
				$i2++;
			}
		}
	}

	$ret->{meeting_points} = \@meeting_points;

	return $ret;
}

sub route_to_ajax {
	my (@stopovers) = @_;

	my @route_entries;

	for my $stop (@stopovers) {
		my @stop_entries = ( $stop->{stop}{name} );
		my $platform;

		if ( $stop->{arrival}
			and my $arr = $strp->parse_datetime( $stop->{arrival} ) )
		{
			my $delay = ( $stop->{arrivalDelay} // 0 ) / 60;
			$platform = $stop->{arrivalPlatform};

			push( @stop_entries, $arr->epoch, $delay );
		}
		else {
			push( @stop_entries, q{}, q{} );
		}

		if ( $stop->{departure}
			and my $dep = $strp->parse_datetime( $stop->{departure} ) )
		{
			my $delay = ( $stop->{departureDelay} // 0 ) / 60;
			$platform //= $stop->{departurePlatform} // q{};

			push( @stop_entries, $dep->epoch, $delay, $platform );
		}
		else {
			push( @stop_entries, q{}, q{}, q{} );
		}

		push( @route_entries, join( ';', @stop_entries ) );
	}

	return join( '|', @route_entries );
}

# Input: List of transport.rest stopovers
# Output: List of preprocessed stops. Each is a hash with the following keys:
#   lat: float
#   lon: float
#   name: str
#   arr: DateTime
#   dep: DateTime
#   arr_delay: int
#   dep_delay: int
#   platform: str
sub stopovers_to_route {
	my (@stopovers) = @_;
	my @route;

	for my $stop (@stopovers) {
		my @stop_lines = ( $stop->{stop}{name} );
		my ( $platform, $arr, $dep, $arr_delay, $dep_delay );

		if (    $stop->{arrival}
			and $arr = $strp->parse_datetime( $stop->{arrival} ) )
		{
			$arr_delay = ( $stop->{arrivalDelay} // 0 ) / 60;
			$platform //= $stop->{arrivalPlatform};
		}

		if (    $stop->{departure}
			and $dep = $strp->parse_datetime( $stop->{departure} ) )
		{
			$dep_delay = ( $stop->{departureDelay} // 0 ) / 60;
			$platform //= $stop->{departurePlatform};
		}

		push(
			@route,
			{
				lat       => $stop->{stop}{location}{latitude},
				lon       => $stop->{stop}{location}{longitude},
				name      => $stop->{stop}{name},
				arr       => $arr,
				dep       => $dep,
				arr_delay => $arr_delay,
				dep_delay => $dep_delay,
				platform  => $platform,
			}
		);

	}
	return @route;
}

sub polyline_to_line_pairs {
	my (@polyline) = @_;
	my @line_pairs;
	for my $i ( 1 .. $#polyline ) {
		push(
			@line_pairs,
			[
				[ $polyline[ $i - 1 ][1], $polyline[ $i - 1 ][0] ],
				[ $polyline[$i][1],       $polyline[$i][0] ]
			]
		);
	}
	return @line_pairs;
}

sub intersection {
	my ($self) = @_;

	my @trips    = split( qr{;}, $self->stash('trips') );
	my @trip_ids = map { [ split( qr{,}, $_ ) ] } @trips;

	$self->render_later;

	my @polyline_requests
	  = map { $self->hafas->get_polyline_p( @{$_} ) } @trip_ids;
	Mojo::Promise->all(@polyline_requests)->then(
		sub {
			my ( $pl1, $pl2 ) = map { $_->[0] } @_;
			my @polyline1 = @{ $pl1->{polyline} };
			my @polyline2 = @{ $pl2->{polyline} };
			my @station_coordinates;

			my @markers;
			my $next_stop;

			my $now = DateTime->now( time_zone => 'Europe/Berlin' );

			my @line1_pairs = polyline_to_line_pairs(@polyline1);
			my @line2_pairs = polyline_to_line_pairs(@polyline2);

			my @route1
			  = stopovers_to_route( @{ $pl1->{raw}{stopovers} // [] } );
			my @route2
			  = stopovers_to_route( @{ $pl2->{raw}{stopovers} // [] } );

			my $train1_pos = estimate_train_positions2(
				now      => $now,
				route    => \@route1,
				features => $pl1->{raw}{polyline}{features},
			);

			my $train2_pos = estimate_train_positions2(
				now      => $now,
				route    => \@route2,
				features => $pl2->{raw}{polyline}{features},
			);

			my $intersection = estimate_train_intersection(
				routes   => [ \@route1, \@route2 ],
				features => [
					$pl1->{raw}{polyline}{features},
					$pl2->{raw}{polyline}{features}
				],
			);

			for my $meeting_point ( @{ $intersection->{meeting_points} } ) {
				push(
					@station_coordinates,
					[
						[ $meeting_point->{lat}, $meeting_point->{lon} ],
						[ $meeting_point->{timestamp}->strftime('%H:%M') ]
					]
				);
			}

			push(
				@markers,
				{
					lat   => $train1_pos->{position_now}[0],
					lon   => $train1_pos->{position_now}[1],
					title => $pl1->{name}
				},
				{
					lat   => $train2_pos->{position_now}[0],
					lon   => $train2_pos->{position_now}[1],
					title => $pl2->{name}
				},
			);

			$self->render(
				'route_map',
				title        => "DBF",
				hide_opts    => 1,
				with_map     => 1,
				intersection => 1,
				train1_no =>
				  scalar( $pl1->{raw}{line}{additionalName} // $pl1->{name} ),
				train2_no =>
				  scalar( $pl2->{raw}{line}{additionalName} // $pl2->{name} ),
				likely_pair => $intersection->{stop_pair}
				? $intersection->{stop_pair}[0]
				: undef,
				time            => scalar $intersection->{first_meeting_time},
				polyline_groups => [
					{
						polylines  => [ @line1_pairs, @line2_pairs ],
						color      => '#ffffff',
						opacity    => 0,
						fit_bounds => 1,
					},
					{
						polylines => [@line1_pairs],
						color     => '#005080',
						opacity   => 0.6,
					},
					{
						polylines => [@line2_pairs],
						color     => '#800050',
						opacity   => 0.6,
					}
				],
				markers             => [@markers],
				station_coordinates => [@station_coordinates],
			);
		}
	)->catch(
		sub {
			my ($err) = @_;
			$self->render(
				'route_map',
				title     => "DBF",
				hide_opts => 1,
				with_map  => 1,
				error     => $err,
			);
		}
	)->wait;
}

sub route {
	my ($self)  = @_;
	my $trip_id = $self->stash('tripid');
	my $line_no = $self->stash('lineno');

	my $from_name = $self->param('from');
	my $to_name   = $self->param('to');

	$self->render_later;

	$self->hafas->get_polyline_p( $trip_id, $line_no )->then(
		sub {
			my ($pl) = @_;

			my @polyline = @{ $pl->{polyline} };
			my @station_coordinates;

			my @markers;
			my $next_stop;

			my $now = DateTime->now( time_zone => 'Europe/Berlin' );

			# used to draw the train's journey on the map
			my @line_pairs = polyline_to_line_pairs(@polyline);

			my @route = stopovers_to_route( @{ $pl->{raw}{stopovers} // [] } );

			# Prepare from/to markers and name/time/delay overlays for stations
			for my $stop (@route) {
				my @stop_lines = ( $stop->{name} );

				if ( $from_name and $stop->{name} eq $from_name ) {
					push(
						@markers,
						{
							lon   => $stop->{lon},
							lat   => $stop->{lat},
							title => $stop->{name},
							icon  => 'goldIcon',
						}
					);
				}
				if ( $to_name and $stop->{name} eq $to_name ) {
					push(
						@markers,
						{
							lon   => $stop->{lon},
							lat   => $stop->{lat},
							title => $stop->{name},
							icon  => 'greenIcon',
						}
					);
				}

				if ( $stop->{platform} ) {
					push( @stop_lines, 'Gleis ' . $stop->{platform} );
				}
				if ( $stop->{arr} ) {
					my $arr_line = $stop->{arr}->strftime('Ankunft: %H:%M');
					if ( $stop->{arr_delay} ) {
						$arr_line .= sprintf( ' (%+d)', $stop->{arr_delay} );
					}
					push( @stop_lines, $arr_line );
				}
				if ( $stop->{dep} ) {
					my $dep_line = $stop->{dep}->strftime('Abfahrt: %H:%M');
					if ( $stop->{dep_delay} ) {
						$dep_line .= sprintf( ' (%+d)', $stop->{dep_delay} );
					}
					push( @stop_lines, $dep_line );
				}

				push( @station_coordinates,
					[ [ $stop->{lat}, $stop->{lon} ], [@stop_lines], ] );
			}

			my $train_pos = estimate_train_positions2(
				now      => $now,
				route    => \@route,
				features => $pl->{raw}{polyline}{features},
			);

			push(
				@markers,
				{
					lat   => $train_pos->{position_now}[0],
					lon   => $train_pos->{position_now}[1],
					title => $pl->{name}
				}
			);
			$next_stop = $train_pos->{next_stop};

			$self->render(
				'route_map',
				title      => $pl->{name},
				hide_opts  => 1,
				with_map   => 1,
				ajax_req   => "${trip_id}/${line_no}",
				ajax_route => route_to_ajax( @{ $pl->{raw}{stopovers} // [] } ),
				ajax_polyline => join( '|',
					map { join( ';', @{$_} ) } @{ $train_pos->{positions} } ),
				origin => {
					name => $pl->{raw}{origin}{name},
					ts   => $pl->{raw}{departure}
					? scalar $strp->parse_datetime( $pl->{raw}{departure} )
					: undef,
				},
				destination => {
					name => $pl->{raw}{destination}{name},
					ts   => $pl->{raw}{arrival}
					? scalar $strp->parse_datetime( $pl->{raw}{arrival} )
					: undef,
				},
				train_no        => scalar $pl->{raw}{line}{additionalName},
				operator        => scalar $pl->{raw}{line}{operator}{name},
				next_stop       => $next_stop,
				polyline_groups => [
					{
						polylines  => [@line_pairs],
						color      => '#00838f',
						opacity    => 0.6,
						fit_bounds => 1,
					}
				],
				station_coordinates => [@station_coordinates],
				markers             => [@markers],
			);
		}
	)->catch(
		sub {
			my ($err) = @_;
			$self->render(
				'route_map',
				title     => "DBF",
				hide_opts => 1,
				with_map  => 1,
				error     => $err,
			);

		}
	)->wait;
}

sub ajax_route {
	my ($self)  = @_;
	my $trip_id = $self->stash('tripid');
	my $line_no = $self->stash('lineno');

	delete $self->stash->{layout};

	$self->render_later;

	$self->hafas->get_polyline_p( $trip_id, $line_no )->then(
		sub {
			my ($pl) = @_;

			my $now = DateTime->now( time_zone => 'Europe/Berlin' );

			my @route = stopovers_to_route( @{ $pl->{raw}{stopovers} // [] } );

			my $train_pos = estimate_train_positions2(
				now      => $now,
				route    => \@route,
				features => $pl->{raw}{polyline}{features},
			);

			my @polyline = @{ $pl->{polyline} };
			$self->render(
				'_map_infobox',
				ajax_req   => "${trip_id}/${line_no}",
				ajax_route => route_to_ajax( @{ $pl->{raw}{stopovers} // [] } ),
				ajax_polyline => join( '|',
					map { join( ';', @{$_} ) } @{ $train_pos->{positions} } ),
				origin => {
					name => $pl->{raw}{origin}{name},
					ts   => $pl->{raw}{departure}
					? scalar $strp->parse_datetime( $pl->{raw}{departure} )
					: undef,
				},
				destination => {
					name => $pl->{raw}{destination}{name},
					ts   => $pl->{raw}{arrival}
					? scalar $strp->parse_datetime( $pl->{raw}{arrival} )
					: undef,
				},
				next_stop => $train_pos->{next_stop},
			);
		}
	)->catch(
		sub {
			my ($err) = @_;
			$self->render(
				'_error',
				error => $err,
			);
		}
	)->wait;
}

1;