package App::MPD::Feeder;

use strict;
use warnings;
use utf8;
use feature 'state';

use App::MPD::Feeder::DB;
use App::MPD::Feeder::Options;
use App::MPD::Feeder::WorkQueue;
use DBD::Pg;
use DBI;
use Getopt::Long;
use IO::Async::Signal;
use IO::Async::Timer::Periodic;
use Log::Any qw($log);
use Net::Async::MPD;
use Object::Pad;
use Syntax::Keyword::Try;

class App::MPD::Feeder {
    has $cfg_file :reader;
    has $opt :reader;
    has $db :reader;
    has $db_needs_update :writer = 1;
    has $mpd :reader;
    has $idler;
    has $work_queue = App::MPD::Feeder::WorkQueue->new;
    has $last_mpd_comm;

use constant DEFAULT_CONFIG_FILE => '/etc/mpd-feeder/mpd-feeder.conf';

    ADJUST {
        Getopt::Long::Configure('pass_through');
        Getopt::Long::GetOptions('cfg|config=s' => \$cfg_file);
        Getopt::Long::Configure('no_pass_through');

        $cfg_file //= DEFAULT_CONFIG_FILE if -e DEFAULT_CONFIG_FILE;

        $self->configure;

        $db_needs_update = 0 if $opt->skip_db_update;
    }

    method configure {
        my $new_opt = App::MPD::Feeder::Options->new;

        $new_opt->parse_config_file($cfg_file) if $cfg_file;

        $new_opt->parse_command_line;

        Log::Any::Adapter->set( Stderr => log_level => $new_opt->log_level );

        $opt = $new_opt;

        $db = App::MPD::Feeder::DB->new( opt => $opt );
    }

    method connect_mpd {
        return if $mpd;

        my %conn = ( auto_connect => 1 );
        $conn{host} = $opt->mpd_host if $opt->mpd_host;
        $conn{port} = $opt->mpd_port if $opt->mpd_port;

        $mpd = Net::Async::MPD->new(%conn);

        $mpd->on(
            close => sub {
                die "Connection to MPD lost";
            }
        );
        $mpd->on(
            playlist => sub {
                $work_queue->add('playlist');
            }
        );
        $mpd->on(
            database => sub {
                $work_queue->add('database');
            }
        );

        my $int_signal_handler = sub {
            state $signal_count = 0;
            $signal_count++;
            $log->debug("Signal received. Stopping loop");
            $work_queue->add('quit');
            $self->break_idle;

            if ( $signal_count > 1 ) {
                $log->warn("Another signal received (#$signal_count)");
                $log->warn("Exiting abruptly");
                exit 2;
            }
        };

        for (qw(TERM INT)) {
            $mpd->loop->add(
                IO::Async::Signal->new(
                    name       => $_,
                    on_receipt => $int_signal_handler,
                )
            );
        }

        $mpd->loop->add(
            IO::Async::Signal->new(
                name       => 'HUP',
                on_receipt => sub {
                    $log->debug("SIGHUP received. Scheduling reload");
                    $work_queue->add('reload');
                    $self->break_idle;
                },
            )
        );

        $mpd->loop->add(
            IO::Async::Signal->new(
                name       => 'USR1',
                on_receipt => sub {
                    $log->debug("SIGUSR1 received. Dumping configuration to STDERR");
                    my $old = select \*STDERR;
                    try {
                        $opt->dump;
                    }
                    finally {
                        select $old;
                    }
                },
            )
        );
    }

    method connect_db {
        $db->connect($opt);
        $self->update_db;
    }

    method update_db($force = undef) {
        if (!$db_needs_update and !$force) {
            $log->debug("Skipping DB update");
            return;
        }

        $log->info('Updating song database');
        $self->connect_mpd;

        my $rows = $mpd->send('listallinfo')->get;

        $log->trace('got all songs from MPD');

        $db->start_update;
        try {
            my $song_count;

            foreach my $entry (@$rows) {
                next unless exists $entry->{file};

                $self->db->store_song( $entry->{file},
                    $entry->{AlbumArtist} // $entry->{Artist},
                    $entry->{Album} );

                $song_count++;
            }

            my ($total_songs, $total_artists, $total_albums,
                $new_songs,   $new_artists,   $new_albums
            ) = $self->db->finish_update;

            $log->info(
                "Updated data about $song_count songs (including $new_songs new), "
                    . "$total_artists artists (including $new_artists new) "

                    . "and $total_albums albums (including $new_albums new)"
            );

            $db_needs_update = 0;
        }
        catch {
            my $err = $@;
            $self->db->cancel_update;
            die $err;
        }
    }

    method queue_songs($num = undef) {
        $self->connect_db;
        if (!defined $num) {
            $self->connect_mpd;
            $log->trace("Requesting playlist");
            my $present = $mpd->send('playlist')->get // [];
            $present = scalar(@$present);

            $log->notice( "Playlist contains $present songs. Wanted: "
                    . $opt->target_queue_length );
            if ( $present < $opt->target_queue_length ) {
                $self->queue_songs(
                    $opt->target_queue_length - $present );
            }

            return;
        }

        my @list = $self->db->find_suitable_songs($num);

        die "Found no suitable songs" unless @list;

        if ( @list < $num ) {
            $log->warn(
                sprintf(
                    'Found only %d suitable songs instead of %d',
                    scalar(@list), $num
                )
            );
        }

        $log->info("About to add $num songs to the playlist");

        my @paths;
        for my $song (@list) {
            my $path = $song->{song};
            $path =~ s/"/\\"/g;
            push @paths, $path;
        }

        $log->debug( "Adding " . join( ', ', map {"«$_»"} @paths ) );
        # MPD needs raw bytes
        utf8::encode($_) for @paths;
        my @commands;
        for (@paths) {
            push @commands, [ add => "\"$_\"" ];
        }
        $self->connect_mpd;
        my $f = $mpd->send( \@commands );
        $f->on_fail( sub { die @_ } );
        $f->on_done(
            sub {
                $self->db->note_song_qeued($_) for @list;
            }
        );
        $f->get;
    }

    method stop {
        undef $mpd;

        $db->disconnect;
    }

    method handle_work_queue {
        while ( my $item = $work_queue->next ) {
            if ( $item eq 'playlist' ) {
                $self->queue_songs;
            }
            elsif ( $item eq 'database' ) {
                $db_needs_update = 1;
                $self->update_db;
            }
            elsif ( $item eq 'reload' ) {
                $log->notice("disconnecting and re-starting");
                $self->stop;

                my @exec =
                    ( $0, '--config', $self->cfg_file, '--skip-db-update' );
                if ( $log->is_trace ) {
                    $log->trace( 'exec '
                            . join( ' ', map { /\s/ ? "'$_'" : $_ } @exec ) );
                }
                exec(@exec);
            }
            elsif ( $item eq 'quit' ) {
                $log->trace("quitting");
                $self->stop;
                exit 0;
            }
            else {
                die "Unknown work queue item '$item'";
            }
        }
    }

    method break_idle {
        if ($idler && !$idler->is_ready) {
            $log->trace("hand-sending 'noidle'");
            undef $idler;
            $mpd->{mpd_handle}->write("noidle\n");;
        }
        else {
            $log->trace("no idler found");
        }
    }

    method run_loop {
        $self->connect_mpd;
        $self->connect_db;

        $mpd->loop->add(
            IO::Async::Timer::Periodic->new(
                interval => 60,
                on_tick  => sub {
                    if ( time - $last_mpd_comm > 300 ) {

                        $log->trace(
                            "no active MPD communication for more that 5 minutes"
                        );
                        $log->trace("forcing alive check");
                        $self->break_idle;
                    }
                    else {
                        $log->trace("contacted MPD less than 5 minutes ago. skipping alive check");
                    }
                },
            )->start
        );

        $self->queue_songs;

        for ( ;; ) {
            $log->debug("Waiting idle. PID=$$");
            $last_mpd_comm = time;
            $idler = $mpd->send("idle database playlist");
            my $result = $idler->get;
            undef $idler;

            if ($result and $result->{changed}){
                my $changed = $result->{changed};
                $changed = [ $changed ] unless ref $changed;

                $mpd->emit($_) for @$changed;
            }

            $log->trace('got out of idle');

            $self->handle_work_queue;
        }
    }
}

