#!/usr/bin/perl -w

use strict;

use CGI; # for escape
use Data::Dumper;
use HTTP::Response;
use POE qw(Component::Server::HTTP Component::MPG123);

$| = 1;
my $port = 8000;                    # HTTP server port
my $mp3dir = "/home/hossman/mp3/";  # where all your mp3s are
my @song_queue =
    # initial queue of songs to play (if any)
    (
#     $mp3dir . 'a.mp3',
#     $mp3dir . 'b.mp3',
    );
##################################################################

# we'll fill this up.
my $global_status = { state => 'stoped',
		      total_frames => 0, total_time => 0,
		      last_frame => 0, last_time => 0,
		  };

##
#
# The MPG123 Component
#
# much of this was taken verbatim from the
# POE::Component::MPG123 test script
#
POE::Component::MPG123->spawn( alias => 'song_manager' );

 POE::Session->create
    ( inline_states => {
	_start => sub {
	    my ($kernel, $heap) = @_[KERNEL, HEAP];
	    $kernel->alias_set( 'song_manager' );
	    
	    # Start the first song.
	    &play_next($kernel);
	},
	
	_stop => sub { },
	
	# Receive status events from mpg123.
	status => sub {
	    my ( $kernel, $heap,
		 $frames_played, $frames_left,
		 $time_played, $time_left
		 ) = @_[KERNEL, HEAP, ARG0..ARG3];
	    
	    $global_status->{state} = "playing";
	    unless ($global_status->{total_frames}) {
		$global_status->{total_frames} = $frames_left;
		$global_status->{total_time}   = $time_left;
	    }
	    $global_status->{frame_count}++;
	    $global_status->{last_frame} = $frames_played;
	    $global_status->{last_time}  = $time_played;
	    
	    # Rather than wait for a specific frame and call
	    # it the end of the song, I'll set a brief delay
	    # here to time out if frames
	    # stop playing.
	    
	    $kernel->delay( song_timeout => 0.25 );
	},
	
	song_info => sub {
	    my ($kernel, $heap, $info) = @_[KERNEL, HEAP, ARG0];
	    $global_status->{song_info} = $info;
	},
	
	file_info => sub {
	    my ($kernel, $heap, $info) = @_[KERNEL, HEAP, ARG0];
	    $global_status->{file_info} = $info;
	},
      
	# The pause succeeded.
	
	song_paused => sub {
	    my ($kernel, $heap) = @_[KERNEL, HEAP];
	    $global_status->{state} = "paused";
	},
	
	# The song resumed after we asked it to.
	
	song_resumed => sub {
	    my ($kernel, $heap) = @_[KERNEL, HEAP];
	    $global_status->{state} = "playing";
	},
	
	# The song stopped naturally.
	
	song_stopped => sub {
	    my ($kernel, $heap) = @_[KERNEL, HEAP];
	    $global_status->{state} = "stoped";
	    $global_status->{file_info} = undef;
	    $global_status->{song_info} = undef;
	    $global_status->{total_time}   = 0;
	    $global_status->{total_frames} = 0;
	    $global_status->{last_time}   = 0;
	    $global_status->{last_frame}   = 0;
	    &play_next($kernel);
        },

	# The player has quit.
	
	player_quit => sub {
	    my ($kernel, $heap) = @_[KERNEL, HEAP];
	    $global_status->{state} = "player quit";
	    
	},
	
	### Miscellaneous event handlers.
	debug   => sub { },
	_child  => sub { },
	_signal => sub { 0 },
    }
      );

##
#
# The HTTP Component
# 
# The docs for this component are a little lacking ...
# but this seems to work
#
my $httpd = new POE::Component::Server::HTTP
    (
     Port => 8000,
     Headers => {
	 'Server' => 'My Server',
	 'Content-type' => 'text/html',
     },
     
     ContentHandler => {
	 '/pause/' => \&httpd_pause_handler,
	 '/req/' => \&httpd_req_handler,
	 '/list/' => \&httpd_list_handler,
	 '/next/' => \&httpd_next_handler,
	 '/' => \&httpd_status_handler,
     },
     );
#
# HTTPD Handlers
#
#
sub httpd_req_handler {
    # the really cool one, we unshift a song on to the head
    # of the list and queue it
    
    my ($request, $response) = @_;

    my $song = CGI::unescape($request->uri->query());
    my $res = "";
    if (-f $song) {
	push @song_queue, $song;
	$res = "REQUEST ACCEPTED: $song\n";
	&play_next($poe_kernel);
    } else {
	$res = "what are you smoking? (no $song)\n";
    }
    $response->content
	(&make_html_response($res, &get_status_info));
    
    $response->code(RC_OK);
    return RC_OK;   
}
sub httpd_list_handler {
    my ($request, $response) = @_;

    my @songs = `find $mp3dir -follow -name \*.mp3`;
    my $links = join ' ', map {
	chomp;
	"<a href=\"/req/?" . CGI::escape($_) .
	    "\">$_</a><br>" } @songs;
    
    $response->code(RC_OK);
    $response->content
	(&make_html_response("Pick a song from the list below",
			     $links));
	return RC_OK;   
}
sub httpd_pause_handler {
    my ($request, $response) = @_;
    
    $poe_kernel->post( mpg123 => 'pause' );
    
    $response->code(RC_OK);
    $response->content
	(&make_html_response("The current song has been (un)paused",
			     &get_status_info));
    return RC_OK;   
}
sub httpd_next_handler {
    my ($request, $response) = @_;
    
    $poe_kernel->post( mpg123 => 'stop');
    
    $response->code(RC_OK);
    $response->content
	(&make_html_response("The last song was skipped",
			     &get_status_info));
    return RC_OK;   
}
sub httpd_status_handler {
    my ($request, $response) = @_;
    
    $response->code(RC_OK);
    $response->content
	(&make_html_response(&get_status_info));
	
		       
    return RC_OK;   
}

sub make_html_response {
    my ($r) = ('<html><body>' .
	       '[ <a href="/next/">skip song</a> | ' .
	       '<a href="/pause/">(un)pause</a> | ' .
	       '<a href="/list/">Make a Request</a> | ' . 
	       '<a href="/">Reload Status</a> ]' .
	       '<hr>' .
	       join('<hr>', @_) .
	       '<p></body></html>');
    return $r;
}

sub play_next {
    # takes a kernel,
    # plays if the state is "stoped" and there's a song waiting
    return unless scalar(@song_queue);
    return unless 'stoped' eq $global_status->{state};
    $_[0]->post( mpg123 => play => shift(@song_queue) );
}

sub get_status_info {
    my $r = "<pre>";
    $r .= "\nCurrent State: " . $global_status->{state} . "\n";
    
    $r .= "Total Frames: " . $global_status->{total_frames} . "\n";
    $r .= "Total Time: " .   $global_status->{total_time} . "\n";
    
    $r .= "Elapsed Frames: " . $global_status->{last_frame} . "\n";
    $r .= "Elapsed Time: " .   $global_status->{last_time} . "\n";
    
    $r .= "\nSong...\n" . Dumper($global_status->{song_info});
    $r .= "\nFile...\n" . Dumper($global_status->{file_info});

    $r .= "\nQueue...\n" . join("\n", @song_queue);
    $r .= "</pre>";
    return $r
}


# Kick the kernel
$poe_kernel->run();
exit 0;