#!/usr/bin/perl
# jukebox.pl - GTK2 jukebox
# Copyright (C) 2002-2005  Toby A Inkster
 
$ver = '2.1';
    
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or   
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

# Stuff that you may like to change.

# path to ogg files!
$path = $ENV{'JUKEBOX'} || '/usr/share/jukebox';

# summarise long song names. how long is long?
$summarise = 60;

# place to output "now playing" data
$nppath = $ENV{'NOWPLAYING'} || ($ENV{'HOME'} . '/.jukebox-np');

# Don't change below here unless you know what you're doing

# Load modules. These should all be on CPAN.

# threading
use threads;
use threads::shared;
use Thread::Queue;

# gui
use Glib;
use Gtk2 '-init';
use Gtk2::SimpleList;
use constant TRUE  => 1;
use constant FALSE => 0;

# audio
use Ogg::Vorbis::Header;
use SDL;
use SDL::Mixer;
use SDL::Music;

# files
use File::Find;

# POSIX
use POSIX;

# queue for songs (and textual representation of it!)
my @queue : shared = ();
my $tQueue : shared = '';

# list of all songs
my @allSongs : shared = &getSongList;

# current song
my $nowSong : shared = '';
my $nowSongDetails : shared = '';
       
# InstaQuit
my $instaQuit : shared = FALSE;

$guiThread = threads->create(\&drawGui);

# main loop
while ($nowSong ne '*') {
        $nowSong = &qPop;
        if ($instaQuit == FALSE) {
                if (!defined $nowSong) {
                        $nowSong = &randomSong;
                }
                if ($nowSong ne '*') {
                        $nowSongDetails = &getDetails($nowSong);
                        &np($nowSong);
                        &playSong($nowSong);
                }
        } else {
                &np('');
                exit;
        }
}

exit;

###################
## Player::Queue
###################

sub qPush {
        my $song = shift @_;
        push @queue, $song;
        $tQueue = ppQueue(@queue);
}

sub qPop {
        my $song = shift @queue;
        $tQueue = ppQueue(@queue);
        return $song;
}

sub ppQueue {
        my $r = '';
        while (my $s = shift) {
                if ($s eq '*') {
                        $r .= "[exit]\n"
                } else {
                        $r .= '.' . $s . "\n" ;
                }
        }
        chomp $r;
        return $r;
}

###################
## np
###################

sub np {
        my $song = shift @_;
        open (NP, ">$nppath");
        print NP "$song\n";
        close NP;
}

###################
## Player::Play
###################

sub playSong {
        my $songfile = shift @_;
       
        my $mixer = SDL::Mixer->new();
       
        my $music =  new SDL::Music("$path$songfile");
        $mixer->play_music($music,1);
       
        while ($mixer->playing_music() || $mixer->music_paused() || $mixer->fading_music() )
                { sleep 1; }
}

sub killSong {
        $mixer = SDL::Mixer->new();
        $mixer->fade_out_music(1500);
}

sub pauseSong {
        $mixer = SDL::Mixer->new();
        $mixer->pause_music;
}

sub resumeSong {
        $mixer = SDL::Mixer->new();
        $mixer->resume_music;
}

sub setSongVolume {
        $vol = shift @_;
        $mixer = SDL::Mixer->new();
        $mixer->music_volume($vol);
}

sub getDetails {

        my $song = shift @_;
        my $r = '';
        my %details = ();

        my $ogg = Ogg::Vorbis::Header->new("$path$song");
        foreach my $com ($ogg->comment_tags) {
                $com =~ tr/[A-Z]/[a-z]/;
                @t = $ogg->comment($com);
                $details{$com} .= $t[0];
        }
        while (my ($k, $v) = each %{$ogg->info}) {
                $details{$k} = $v;
        }

        if ($details{'artist'}) {
                $r .= 'Artist: ' . $details{'artist'} . "\n";
        }
        if ($details{'title'}) {
                $r .= 'Title: ' . $details{'title'} . "\n";
        }
        if ($details{'album'}) {
                $r .= 'Album: ' . $details{'album'}. "\n";
        }
        if ($details{'date'}) {
                $r .= 'Date: ' . $details{'date'} . "\n";
        }
        my $min = POSIX::floor($details{'length'} / 60);
        my $sec = $details{'length'} % 60;
        $sec = "0$sec" unless ($sec > 9);
        my $bitrate = POSIX::floor($details{'bitrate_nominal'} / 1024);
        $r .= "File: .$song\n";
        $r .= "Length: $min:$sec (at $bitrate kbps)";

        return $r;
}

###################
## Player::Songlist
###################

sub randomSong {
        my $r = int(rand($#allSongs + 1));
        return $allSongs[$r];
}

sub getSongList {
        $l = length($path);
        @r = ();
        find(\&getSongListWanted,$path);
        return sort (@r);
}

sub getSongListWanted {
        if (/\.ogg$/) {
                $p = substr($File::Find::name, $l);
                push @r, $p;
        }
}

sub getSongListSort {
        my @files = grep { not /^\.\.?$/ } @_;
        return sort @files;
}

###################
## GUI::Draw
###################

sub drawGui {

        # create main window
        $window = Gtk2::Window->new;
        $window->set_title("Jukebox $ver");
        $window->signal_connect(destroy => \&eventExit);
        $window->set_border_width(3);
        $window->set_icon_from_file("$path/icon.png");
       
        # list of files
        $flist = Gtk2::SimpleList->new('Song' => 'text');
        $flist->set_rules_hint(TRUE);
        $flist->get_selection->set_mode ('multiple');
        $flist->get_selection->unselect_all;
        $flist->signal_connect (row_activated => \&eventBtnAdd);
        $hsummarise = POSIX::floor($summarise / 3);
        foreach my $s (@allSongs) {
                $p = substr($s,1);
                $p =~ s#\.ogg$##;
                $p =~ s#/# - #g;
                $p =~ s#_# #g;
                $p =~ s/\b(\w)/\U$1/g;
                if (length($p) > $summarise) {
                        $l = length($p);
                        $p = substr($p, 0, $hsummarise) . ' ... ' . substr($p, $l - $hsummarise, $hsummarise);
                }
                push @{$flist->{data}}, [ $p ];
        }
        $sw1 = Gtk2::ScrolledWindow->new(undef, undef);
        $sw1->set_shadow_type ('etched-in');
        $sw1->set_policy ('automatic', 'automatic');
        $sw1->add($flist);

        # status field
        $statusfield = Gtk2::Label->new;
        $statusfield->set_alignment(0,0);
        Glib::Timeout->add (500, sub {
                $x = $nowSongDetails;   # NOTE: These assignments seem useless, but
                $y = $tQueue;           # they seem to wake up threads::shared.
                $statusfield->set_text($nowSongDetails);
                $queuefield->set_text($tQueue);
                1;
        });

        # queue field
        $queuefield = Gtk2::Label->new('q');
        $queuefield->set_alignment(0,0);

        # boxes and frames for arranging things
        $vbox = Gtk2::VBox->new;
        $vbox->set_border_width(3);
        $frame = Gtk2::Frame->new('Controls');
        $frame->set_border_width(3);
        $frame->add($vbox);
        $hbox = Gtk2::HBox->new;
        $hbox->set_border_width(3);
        $hbox->pack_start($sw1, TRUE, TRUE, 0);
        $hbox->pack_start($frame, FALSE, FALSE, 0);
        $hr = Gtk2::HSeparator->new;
        $outerbox = Gtk2::VBox->new;
        $outerbox->pack_start($hbox, TRUE, TRUE, 0);
        $outerbox->pack_start($statusfield, FALSE, TRUE, 0);
        $outerbox->pack_start($hr, FALSE, FALSE, 0);
        $outerbox->pack_start($queuefield, FALSE, TRUE, 0);
        $window->add($outerbox);

        # buttons for controls
        $button{'add'} = Gtk2::Button->new('En_queue');
        $vbox->pack_start($button{'add'}, FALSE, FALSE, 0);
        $button{'add'}->signal_connect(clicked => \&eventBtnAdd);
       
        $button{'pause'} = Gtk2::ToggleButton->new('_Pause');
        $button{'pause'}->set_active(FALSE);
        $vbox->pack_start($button{'pause'}, FALSE, FALSE, 0);
        $button{'pause'}->signal_connect(clicked => \&eventBtnPause);

        $button{'skip'} = Gtk2::Button->new('_Skip');
        $vbox->pack_start($button{'skip'}, FALSE, FALSE, 0);
        $button{'skip'}->signal_connect(clicked => \&eventBtnSkip);
       
        $adj = Gtk2::Adjustment->new(100, 0, 101, 1, 10, 1);
        $adj->signal_connect(value_changed => \&eventBtnVolume);
        $button{'volume'} = Gtk2::HScale->new($adj);
        $button{'volume'}->set_value_pos('bottom');
        $button{'volume'}->set_digits(0);
        $vbox->pack_start($button{'volume'}, FALSE, FALSE, 0);
        $button{'volume'}->signal_connect('move-slider' => \&eventBtnVolume);

        $button{'quit'} = Gtk2::Button->new('E_xit');
        $button{'quit'}->signal_connect(clicked => \&eventExit);
        $vbox->pack_end($button{'quit'}, FALSE, FALSE, 0);

        $button{'end'} = Gtk2::Button->new('_Delayed Exit');
        $vbox->pack_end($button{'end'}, FALSE, FALSE, 0);
        $button{'end'}->signal_connect(clicked => \&eventBtnEnd);

        # show window and enter GTK+2 loop
        $window->set_default_size( 640, 480 );
        $window->show_all;
        Gtk2->main;
       
        $instaQuit = TRUE;

}

###################
## GUI::EventHandlers
###################

sub eventBtnAdd {
        my @indices = $flist->get_selected_indices();
        foreach $i (@indices) {
                &qPush($allSongs[$i]);
        }
}

sub eventBtnEnd {
        &qPush('*');
}

sub eventBtnSkip {
        $button{'pause'}->set_active(FALSE);
        &killSong;
}

sub eventBtnPause {
        if ($button{'pause'}->get_active) {
                &pauseSong;
        } else {
                &resumeSong;
        }
}

sub eventBtnVolume {
        $v1 = $adj->value;
        $v2 = POSIX::floor($v1 * 128 / 100);
        &setSongVolume($v2);
}

sub eventExit {
        $instaQuit = TRUE;
        &killSong;
        Gtk2->main_quit;       
}