// BLAR: BBC Listen Again retargetter
// version 0.1.115 BETA!
// 2007-09-23
// Copyright (c) 2007, Nick Woolley
// Released under the GPL license
// http://www.gnu.org/copyleft/gpl.html
//
// --------------------------------------------------------------------
//
// This is a Greasemonkey user script.
//
// To install, you need Greasemonkey: http://greasemonkey.mozdev.org/
// Then restart Firefox and revisit this script.
// Under Tools, there will be a new menu item to "Install User Script".
// Accept the default configuration and install.
//
// To uninstall, go to Tools/Manage User Scripts,
// select "RetargetListenAgain", and click Uninstall.
//
// --------------------------------------------------------------------
//
// ==UserScript==
// @name          BLAR
// @namespace     http://noodlefactory.co.uk/
// @description   Retargets the BBC Listen Again player from RealPlayer to other backends
// @include       http://www.bbc.co.uk/*/aod.shtml
// @include       http://www.bbc.co.uk/*/aod.shtml*
// ==/UserScript==


var amarok_url = "http://snackpot/~nick/cgi-bin/amarok";

function make_alert(name) 
{
  var nam = name;
  return function()
  {
    alert("invoked '"+nam+"'");
  };
}


// Applies a closure function 'operation' to an HTML node and all it's children in turn.
// The operation() function is called with the current node as it's first argument, the 
// node's parent as it's second, and so up up to the original root_node  - the number of 
// arguments equals the depth in the tree.
//
// Note, a node's children are *not* processed if the operation() function returns 
// the value PRUNE.
var PRUNE = true;
function recursive_apply(root_node, operation)
{
  var node_stack = [];
  
  var iterator;
  iterator = function(node)
  {
    if (!node) return;
    node_stack.unshift(node);
    
    // apply the operation to any child nodes, if the operation
    // didn't ask to prune the recursion here
    if (operation.apply(null, node_stack) != PRUNE)
      for(var ix = 0; ix < node.childNodes.length; ++ix)
        iterator(node.childNodes[ix]);
    
    node_stack.shift();
  }
  
  iterator(root_node);
}


function find_node(root_node, name)
{
  var node = root_node;
  var found;
  found = function()
  {
    if (node.nodeName.toLowerCase() == name) return true;
    var children = node.childNodes;
    for(var ix = 0; ix < children.length; ++ix)
    {
      node = children[ix];
      if (found()) return true;
    }
    return false;
  }
  if (found()) return node;
  return null;
}


// returns a function which, given an element, returns the value of
// the named attribute, if present, else returns null.  The function does *not*
// check the argument is an element.
function get_attribute_value(attr_name) 
{ 
  return function(node) 
  {
    // This includes a work-around for an IE "feature" mentioned here:
    // http://tobielangel.com/2007/1/11/attribute-nightmare-in-ie
    // (Reading this kind of thing just makes me sick with fear and loathing)
    var value = node.getAttribute(attr_name);
    if (value != null && typeof value == "object" && "nodeValue" in value) 
      value = value.nodeValue;
    else
    {
      value = node.attributes[attr_name];
      if (value != null && typeof value == "object" && "nodeValue" in value) 
        value = value.nodeValue;
    }
    return value;
  }
}
  

var get_src_attribute = get_attribute_value("src");
var get_onclick_attribute = get_attribute_value("onclick");


//////////////////////////////////////////////////////////////////////
// FakePlayer
//
// This class looks like the RealPlayer object exposed to the javascript
// world in a BBC listen again page via the document.RP property.
// It does nothing. 

function FakePlayer(src_url)
{
    this.srcUrl = src_url;
}


/*
FakePlayer.prototype = 
{
    CanPause: make_alert("CanPause"),
    CanPlay: make_alert("CanPlay"),
    CanStop: make_alert("CanStop"),
    DoPause: make_alert("DoPause"),
    DoPlay: make_alert("DoPlay"),
    DoStop: make_alert("DoStop"),
    GetBandwidthAverage: make_alert("GetBandwidthAverage"),
    GetBufferingTimeElapsed: make_alert("GetBufferingTimeElapsed"),
    GetCanSeek: make_alert("GetCanSeek"),
    GetLength: make_alert("GetLength"),
    GetPlayState: make_alert("GetPlayState"),
    GetPosition: make_alert("GetPosition"),
    GetVolume: make_alert("GetVolume"),
    SetPosition: make_alert("SetPosition"), //function(time)
    SetVolume: make_alert("SetVolume"), //function(volume)
};
*/

FakePlayer.prototype = 
{
  CanPause: function() { return true; },
  CanPlay: function() { return true;},
  CanStop: function() { return true; },
  DoPause: function() { },
  DoPlay: function() {},
  DoStop: function() {},
  GetBandwidthAverage: function() { return 0; },
  GetBufferingTimeElapsed: function() { return 0; },
  GetCanSeek: function() { return false; },
  GetLength: function() { return 0; },
  GetPlayState: function() { return "blah"; },
  GetPosition: function() {},
  GetVolume: function() {},
  SetPosition: function() {}, //function(time)
  SetVolume: function() {}, //function(volume)
};





////////////////////////////////////////////////////////
// The BLAR class
//
// BBC Listen Again Retargeter
//
// This is a base class which does nothing.  You need to subclass it
// with an implementation which does something useful.
// See CgiAmarokBLAR for a practical example.



function BLAR(target_window) 
{
  if (target_window == null) throw "target_window argument must not be null";
  this._targetWindow = target_window;
}

function make_delegate_to(obj, method_name)
{
  var method = obj[method_name];
  return function() { return method.apply(obj, arguments) };
}


// These methods emulate the original logic performed on the BBC
// listen again AOD.shtml page, e.g. updating images and state
// variables.
//
// In general, when overriding thse methods, call the base method
// first before you perform your own actions (unless specifically
// stated otherwise).  This should maintain the original logic.
BLAR.prototype = 
  {
    // this are rebound to call our own versions
    retargettedFunctions: 
    {
      PlayPause: 'playPause',
      Stop: 'stop',
      PosChange: 'posChange',
      VolChange: 'volChange',
      GetStatus: 'getStatus'
    },

    // these are the states as returned by RP.GetPlayState()
    PLAYSTATES:
    {
      STOPPED:    0, // stopped
      CONTACTING: 1, // contacting server
      LOADING:    2, // loading stream
      PLAYING:    3, // playing stream
      PAUSED:     4, // paused
      SEEKING:    5  // seeking       
    },

    _targetWindow: null,

    // a flag used to track the current state of the player
    playstate: 0,
    volume: 0, // FIXME get this from the client


    // starts playing a new url
    play: function(stream_url) 
    {
      this.playstate = this.PLAYSTATES.PLAYING;
      this._targetWindow.ImgPause();
    },
    
    // toggles between play and pause modes
    //
    //
    playPause: function() 
    {
      // The listen again implemenation also calls ImgPause() or
      // ImgPlay() (for play and pause, respectively).  This is
      // handled by resume() and pause().

      switch(this.playstate)
      {
      case this.PLAYSTATES.STOPPED:
      case this.PLAYSTATES.PAUSED:
        this.resume();
        break;

      default: 
        this.pause();
        break;
      }
    },

    // pauses playback
    pause: function()
    {
      this._targetWindow.ImgPlay();
      this.playstate = this.PLAYSTATES.PAUSED;
    },
    
    // resumes from a pause 
    resume: function()
    {
      this._targetWindow.ImgPause();
      this.playstate = this.PLAYSTATES.PLAYING;
    },

    // stops playing
    stop: function() 
    {
      this._targetWindow.ImgPlay();
      this.playstate = this.PLAYSTATES.STOPPED;
    },

    // Changes the playback position of the stream (if this is
    // possible) by the specified number of minutes.
    posChange: function(minutes) 
    {
      
    },

    // Sets the volume property. delta_vol is the amount to change the volume by,
    // and the volume itself is a value from 0 to 100.  
    //
    // The implementation on the listen again page does the following:
    //
    //      if (volume > 80 && delta_vol > 0) volume = 100;
    // else if (volume < 21 && delta_vol < 0) volume = 1;  
    // else volume += delta_vol
    //
    // Also it calls ImgVol()
    volChange: function(delta_vol) 
    {
      if (this.volume > 80 && delta_vol > 0) this.volume = 100;
      else if (this.volume < 21 && delta_vol < 0) this.volume = 1;  
      else this.volume += delta_vol;
      if (this.volume > 100) this.volume = 100;
      if (this.volume < 0) this.volume = 0;
      
      // FIXME do we need to set the volume property in RP, or override ImgVol?
      this._targetWindow.ImgVol();
    },

    // Called periodically by the listen again page to query the
    // playstate by calling RP.GetPlayState().  The playstate values
    // returned by GetPlayState() are as defined in the PLAYSTATES
    // property.
    //
    // Should return a string, typically one of: 'Stopped'/'Loading...' /'Playing'/'Paused'/'Seeking...'
    //
    // Original implementation also does:
    // calls ImgPlay() if stopped or paused 
    // calls ImgPause() if contacting, loading, or playing 
    getStatus: function() 
    {
      var status = "";
      switch(this.playstate)
      {
      case this.PLAYSTATES.STOPPED:    this._targetWindow.ImgPlay(); status =  "Stopped"; break;
      case this.PLAYSTATES.CONTACTING: this._targetWindow.ImgPause(); status =  "Contacting..."; break;
      case this.PLAYSTATES.LOADING:    this._targetWindow.ImgPause(); status =  "Loading..."; break;
      case this.PLAYSTATES.PLAYING:    this._targetWindow.ImgPause(); status =  "Playing"; break;
      case this.PLAYSTATES.PAUSED:     this._targetWindow.ImgPlay(); status =  "Paused"; break;
      case this.PLAYSTATES.SEEKING:    this._targetWindow.ImgPause(); status =  "Seeking"; break;
      default:  status = ""; break;
      }
      return status;
    }

    // Also defined in the AOD player, but currently unimplemented, as
    // these are wrappers for the above:
    //
    // AodStop() - inspect the value of the global 'show_end' and save
    // the resume position using setResume(), then call Stop()
    //
    // FForward(mins) - calls PosChange(mins)
    //
    // Rewind(mins) - calls PosChange(-mins)
    //
    // ImgVol() - sets the volume display by querying RP.GetVolume().
    // Called periodically by to update the volume display.
    //
    // ImgPause() - sets the display status to 'paused'
    // ImgPlay() - sets the display status to 'playing'
    // ImgChange() - something fiddly to do with the document image array
    //
    // some functions mentioned above which are defined in all.js
    //
    // getResume(cookie_id) - gets (and clears) the resume point,  
    //
    // setResume(cookie_id, expiry_period) - saves the resume point
    // (obtained from RP.CurrentPosition) for the audio stream (set in
    // the AudioStream global), with some other information, in the named cookie.
    // 
    // loadResume(cookie_id) - loads the resume point from the aforementioned cookie(s) 
    //
    // checkResume() - loads the resume point from the cookie, if it
    // exists, and if resume is possible, prompts the user if they
    // wish to resume from the start of the stream or the saved resume
    // point. (Called on page load).
    //
    // checkLoaded() - returns true unless realplayer in use and RP.GetPlayState<2 
  };



////////////////////////////////////////////////////////
// The CgiAmarokBLAR class
//
// An subclass of the BLAR class which invokes Amarok via a CGI
// script.

function copy(obj)
{
  var new_obj = {};
  for(var prop in obj) new_obj[prop] = obj[prop];
  return new_obj;
}

function CgiAmarokBLAR(target_window, cgi_url)
{
  // FIXME sanity check needed
  BLAR.call(this, target_window);
  this.cgiUrl = cgi_url;
  // FIXME get volume and status (and position?) from the client
//  GM_xmlhttpRequest
}

CgiAmarokBLAR.prototype = new BLAR("dummy"); // Javascript OO is a bit obscure sometimes, or maybe I'm just being thick
CgiAmarokBLAR.prototype.constructor = CgiAmarokBLAR;

CgiAmarokBLAR.prototype.play = function(stream_url) 
{
  BLAR.prototype.play.call(this, stream_url);
  this.invoke({playurl: stream_url});
};

CgiAmarokBLAR.prototype.pause = function() 
{
  BLAR.prototype.pause.call(this);
  this.invoke({pause: 1});
};

CgiAmarokBLAR.prototype.resume = function() 
{
  BLAR.prototype.resume.call(this);
  this.invoke({play: 1});
};

CgiAmarokBLAR.prototype.stop = function() 
{
  BLAR.prototype.stop.call(this);
  this.invoke({stop: 1});
};

CgiAmarokBLAR.prototype.posChange = function(pos) 
{
  BLAR.prototype.posChange.call(this, pos);
//  this.invoke({: 1}); not yet implemented
  alert("unimplemented");
};

CgiAmarokBLAR.prototype.volChange = function(vol) 
{
  GM_log("volChange: "+vol);
  BLAR.prototype.volChange.call(this, vol);
  this.invoke({setvolume: this.volume});
};

CgiAmarokBLAR.prototype.getStatus = function() 
{
  var status = BLAR.prototype.getStatus.call(this);
//  GM_log("getStatus: "+status);
  return status;
/*
  // FIXME not currently used, as we may need to throttle this repeated querying over the network.
  var status = this.invoke({status: 1});  
  switch (status)
  {
  case 0: status = this.playstate = this.PLAYSTATES.STOPPED; 
  case 1: status = this.playstate = this.PLAYSTATES.PAUSED;
  case 2: status = this.playstate = this.PLAYSTATES.PLAYING;
  default: status = this.playstate = this.PLAYSTATES.STOPPED;
  }
  return status;*/
};


CgiAmarokBLAR.prototype.invoke = function(params)
{
  var components = [];
  for(var param in params)
  {
    components.push(param + "=" + encodeURIComponent(params[param]));
  }
  var url = this.cgiUrl + "?" + components.join("&");

  GM_xmlhttpRequest({method: 'GET',
                     url: url});
}



////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////

function dump(x)
{
    var s;
    for(var k in x) { s += k + "=>" +x[k] + "\n"; }
    alert(s);
}


function rebind(target_window, blar)
{
  var player_node_name = "embed";
  var player_node = find_node(target_window.document, player_node_name);
  if (player_node == null) throw "Could not find player node '"+player_node_name+"'";
  
  var src_url = get_src_attribute(player_node);
  var base_url = target_window.document.location.toString();
  var abs_url = src_url.match(/^\//)?
    base_url.replace(/^([a-z]+:\/\/[^\/]*).*/, "$1"+src_url) :
    base_url.replace(/\/?[^\/]*$/,"/"+src_url); 
    
  blar.play(abs_url);


  player_node.parentNode.removeChild(player_node);
  target_window.document.RP = new FakePlayer(abs_url);

  for(var func in blar.retargettedFunctions)
  {
    var method_name = blar.retargettedFunctions[func];
    target_window[func] = make_delegate_to(blar, method_name);
  }
};

window.addEventListener('load', function() { rebind(this, new CgiAmarokBLAR(this, amarok_url)) }, true);