/* 

 * 	

 *	Copyright 2010 Institut de recherche et d'innovation 

 *	contributor(s) : Samuel Huron 

 *	 

 *	contact@iri.centrepompidou.fr

 *	http://www.iri.centrepompidou.fr 

 *	 

 *	This software is a computer program whose purpose is to show and add annotations on a video .

 *	This software is governed by the CeCILL-C license under French law and

 *	abiding by the rules of distribution of free software. You can  use, 

 *	modify and/ or redistribute the software under the terms of the CeCILL-C

 *	license as circulated by CEA, CNRS and INRIA at the following URL

 *	"http://www.cecill.info". 

 *	

 *	The fact that you are presently reading this means that you have had

 *	knowledge of the CeCILL-C license and that you accept its terms.

*/

(function(global, document) {

  // Popcorn.js does not support archaic browsers

  if ( !document.addEventListener ) {

    global.Popcorn = {

      isSupported: false

    };

    var methods = ( "forEach extend effects error guid sizeOf isArray nop position disable enable destroy " +

          "addTrackEvent removeTrackEvent getTrackEvents getTrackEvent getLastTrackEventId " +

          "timeUpdate plugin removePlugin compose effect parser xhr getJSONP getScript" ).split(/\s+/);

    while ( methods.length ) {

      global.Popcorn[ methods.shift() ] = function() {};

    }

    return;

  }

  var

  AP = Array.prototype,

  OP = Object.prototype,

  forEach = AP.forEach,

  slice = AP.slice,

  hasOwn = OP.hasOwnProperty,

  toString = OP.toString,

  // Copy global Popcorn (may not exist)

  _Popcorn = global.Popcorn,

  //  ID string matching

  rIdExp  = /^(#([\w\-\_\.]+))$/,

  //  Ready fn cache

  readyStack = [],

  readyBound = false,

  readyFired = false,

  //  Non-public internal data object

  internal = {

    events: {

      hash: {},

      apis: {}

    }

  },

  //  Non-public `requestAnimFrame`

  //  http://paulirish.com/2011/requestanimationframe-for-smart-animating/

  requestAnimFrame = (function(){

    return global.requestAnimationFrame ||

      global.webkitRequestAnimationFrame ||

      global.mozRequestAnimationFrame ||

      global.oRequestAnimationFrame ||

      global.msRequestAnimationFrame ||

      function( callback, element ) {

        global.setTimeout( callback, 16 );

      };

  }()),

  refresh = function( obj ) {

    var currentTime = obj.media.currentTime,

      animation = obj.options.frameAnimation,

      disabled = obj.data.disabled,

      tracks = obj.data.trackEvents,

      animating = tracks.animating,

      start = tracks.startIndex,

      registryByName = Popcorn.registryByName,

      animIndex = 0,

      byStart, natives, type;

    start = Math.min( start + 1, tracks.byStart.length - 2 );

    while ( start > 0 && tracks.byStart[ start ] ) {

      byStart = tracks.byStart[ start ];

      natives = byStart._natives;

      type = natives && natives.type;

      if ( !natives ||

          ( !!registryByName[ type ] || !!obj[ type ] ) ) {

        if ( ( byStart.start <= currentTime && byStart.end > currentTime ) &&

                disabled.indexOf( type ) === -1 ) {

          if ( !byStart._running ) {

            byStart._running = true;

            natives.start.call( obj, null, byStart );

            // if the 'frameAnimation' option is used,

            // push the current byStart object into the `animating` cue

            if ( animation &&

                ( byStart && byStart._running && byStart.natives.frame ) ) {

              natives.frame.call( obj, null, byStart, currentTime );

            }

          }

        } else if ( byStart._running === true ) {

          byStart._running = false;

          natives.end.call( obj, null, byStart );

          if ( animation && byStart._natives.frame ) {

            animIndex = animating.indexOf( byStart );

            if ( animIndex >= 0 ) {

              animating.splice( animIndex, 1 );

            }

          }

        }

      }

      start--;

    }

  },

  //  Declare constructor

  //  Returns an instance object.

  Popcorn = function( entity, options ) {

    //  Return new Popcorn object

    return new Popcorn.p.init( entity, options || null );

  };

  //  Popcorn API version, automatically inserted via build system.

  Popcorn.version = "@VERSION";

  //  Boolean flag allowing a client to determine if Popcorn can be supported

  Popcorn.isSupported = true;

  //  Instance caching

  Popcorn.instances = [];

  //  Declare a shortcut (Popcorn.p) to and a definition of

  //  the new prototype for our Popcorn constructor

  Popcorn.p = Popcorn.prototype = {

    init: function( entity, options ) {

      var matches;

      //  Supports Popcorn(function () { /../ })

      //  Originally proposed by Daniel Brooks

      if ( typeof entity === "function" ) {

        //  If document ready has already fired

        if ( document.readyState === "interactive" || document.readyState === "complete" ) {

          entity( document, Popcorn );

          return;

        }

        //  Add `entity` fn to ready stack

        readyStack.push( entity );

        //  This process should happen once per page load

        if ( !readyBound ) {

          //  set readyBound flag

          readyBound = true;

          var DOMContentLoaded  = function() {

            readyFired = true;

            //  Remove global DOM ready listener

            document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );

            //  Execute all ready function in the stack

            for ( var i = 0, readyStackLength = readyStack.length; i < readyStackLength; i++ ) {

              readyStack[ i ].call( document, Popcorn );

            }

            //  GC readyStack

            readyStack = null;

          };

          //  Register global DOM ready listener

          document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

        }

        return;

      }

      //  Check if entity is a valid string id

      matches = rIdExp.exec( entity );

      //  Get media element by id or object reference

      this.media = matches && matches.length && matches[ 2 ] ?

                     document.getElementById( matches[ 2 ] ) :

                     entity;

      //  Create an audio or video element property reference

      this[ ( this.media.nodeName && this.media.nodeName.toLowerCase() ) || "video" ] = this.media;

      //  Register new instance

      Popcorn.instances.push( this );

      this.options = options || {};

      this.isDestroyed = false;

      this.data = {

        // Executed by either timeupdate event or in rAF loop

        timeUpdate: Popcorn.nop,

        // Allows disabling a plugin per instance

        disabled: [],

        // Stores DOM event queues by type

        events: {},

        // Stores Special event hooks data

        hooks: {},

        // Store track event history data

        history: [],

        // Stores ad-hoc state related data]

        state: {

          volume: this.media.volume

        },

        // Store track event object references by trackId

        trackRefs: {},

        // Playback track event queues

        trackEvents: {

          byStart: [{

            start: -1,

            end: -1

          }],

          byEnd: [{

            start: -1,

            end: -1

          }],

          animating: [],

          startIndex: 0,

          endIndex: 0,

          previousUpdateTime: -1

        }

      };

      //  Wrap true ready check

      var isReady = function( that ) {

        var duration, videoDurationPlus;

        if ( that.media.readyState >= 2 ) {

          //  Adding padding to the front and end of the arrays

          //  this is so we do not fall off either end

          duration = that.media.duration;

          //  Check for no duration info (NaN)

          videoDurationPlus = duration != duration ? Number.MAX_VALUE : duration + 1;

          Popcorn.addTrackEvent( that, {

            start: videoDurationPlus,

            end: videoDurationPlus

          });

          if ( that.options.frameAnimation ) {

            //  if Popcorn is created with frameAnimation option set to true,

            //  requestAnimFrame is used instead of "timeupdate" media event.

            //  This is for greater frame time accuracy, theoretically up to

            //  60 frames per second as opposed to ~4 ( ~every 15-250ms)

            that.data.timeUpdate = function () {

              Popcorn.timeUpdate( that, {} );

              that.trigger( "timeupdate" );

              !that.isDestroyed && requestAnimFrame( that.data.timeUpdate );

            };

            !that.isDestroyed && requestAnimFrame( that.data.timeUpdate );

          } else {

            that.data.timeUpdate = function( event ) {

              Popcorn.timeUpdate( that, event );

            };

            if ( !that.isDestroyed ) {

              that.media.addEventListener( "timeupdate", that.data.timeUpdate, false );

            }

          }

        } else {

          global.setTimeout(function() {

            isReady( that );

          }, 1 );

        }

      };

      isReady( this );

      return this;

    }

  };

  //  Extend constructor prototype to instance prototype

  //  Allows chaining methods to instances

  Popcorn.p.init.prototype = Popcorn.p;

  Popcorn.forEach = function( obj, fn, context ) {

    if ( !obj || !fn ) {

      return {};

    }

    context = context || this;

    var key, len;

    // Use native whenever possible

    if ( forEach && obj.forEach === forEach ) {

      return obj.forEach( fn, context );

    }

    if ( toString.call( obj ) === "[object NodeList]" ) {

      for ( key = 0, len = obj.length; key < len; key++ ) {

        fn.call( context, obj[ key ], key, obj );

      }

      return obj;

    }

    for ( key in obj ) {

      if ( hasOwn.call( obj, key ) ) {

        fn.call( context, obj[ key ], key, obj );

      }

    }

    return obj;

  };

  Popcorn.extend = function( obj ) {

    var dest = obj, src = slice.call( arguments, 1 );

    Popcorn.forEach( src, function( copy ) {

      for ( var prop in copy ) {

        dest[ prop ] = copy[ prop ];

      }

    });

    return dest;

  };

  // A Few reusable utils, memoized onto Popcorn

  Popcorn.extend( Popcorn, {

    noConflict: function( deep ) {

      if ( deep ) {

        global.Popcorn = _Popcorn;

      }

      return Popcorn;

    },

    error: function( msg ) {

      throw new Error( msg );

    },

    guid: function( prefix ) {

      Popcorn.guid.counter++;

      return  ( prefix ? prefix : "" ) + ( +new Date() + Popcorn.guid.counter );

    },

    sizeOf: function( obj ) {

      var size = 0;

      for ( var prop in obj ) {

        size++;

      }

      return size;

    },

    isArray: Array.isArray || function( array ) {

      return toString.call( array ) === "[object Array]";

    },

    nop: function() {},

    position: function( elem ) {

      var clientRect = elem.getBoundingClientRect(),

          bounds = {},

          doc = elem.ownerDocument,

          docElem = document.documentElement,

          body = document.body,

          clientTop, clientLeft, scrollTop, scrollLeft, top, left;

      //  Determine correct clientTop/Left

      clientTop = docElem.clientTop || body.clientTop || 0;

      clientLeft = docElem.clientLeft || body.clientLeft || 0;

      //  Determine correct scrollTop/Left

      scrollTop = ( global.pageYOffset && docElem.scrollTop || body.scrollTop );

      scrollLeft = ( global.pageXOffset && docElem.scrollLeft || body.scrollLeft );

      //  Temp top/left

      top = Math.ceil( clientRect.top + scrollTop - clientTop );

      left = Math.ceil( clientRect.left + scrollLeft - clientLeft );

      for ( var p in clientRect ) {

        bounds[ p ] = Math.round( clientRect[ p ] );

      }

      return Popcorn.extend({}, bounds, { top: top, left: left });

    },

    disable: function( instance, plugin ) {

      var disabled = instance.data.disabled;

      if ( disabled.indexOf( plugin ) === -1 ) {

        disabled.push( plugin );

      }

      refresh( instance );

      return instance;

    },

    enable: function( instance, plugin ) {

      var disabled = instance.data.disabled,

          index = disabled.indexOf( plugin );

      if ( index > -1 ) {

        disabled.splice( index, 1 );

      }

      refresh( instance );

      return instance;

    },

    destroy: function( instance ) {

      var events = instance.data.events,

          singleEvent, item, fn;

      //  Iterate through all events and remove them

      for ( item in events ) {

        singleEvent = events[ item ];

        for ( fn in singleEvent ) {

          delete singleEvent[ fn ];

        }

        events[ item ] = null;

      }

      if ( !instance.isDestroyed ) {

        instance.data.timeUpdate && instance.media.removeEventListener( "timeupdate", instance.data.timeUpdate, false );

        instance.isDestroyed = true;

      }

    }

  });

  //  Memoized GUID Counter

  Popcorn.guid.counter = 1;

  //  Factory to implement getters, setters and controllers

  //  as Popcorn instance methods. The IIFE will create and return

  //  an object with defined methods

  Popcorn.extend(Popcorn.p, (function() {

      var methods = "load play pause currentTime playbackRate volume duration preload playbackRate " +

                    "autoplay loop controls muted buffered readyState seeking paused played seekable ended",

          ret = {};

      //  Build methods, store in object that is returned and passed to extend

      Popcorn.forEach( methods.split( /\s+/g ), function( name ) {

        ret[ name ] = function( arg ) {

          if ( typeof this.media[ name ] === "function" ) {

            // Support for shorthanded play(n)/pause(n) jump to currentTime

            // If arg is not null or undefined and called by one of the

            // allowed shorthandable methods, then set the currentTime

            // Supports time as seconds or SMPTE

            if ( arg != null && /play|pause/.test( name ) ) {

              this.media.currentTime = Popcorn.util.toSeconds( arg );

            }

            this.media[ name ]();

            return this;

          }

          if ( arg != null ) {

            this.media[ name ] = arg;

            return this;

          }

          return this.media[ name ];

        };

      });

      return ret;

    })()

  );

  Popcorn.forEach( "enable disable".split(" "), function( method ) {

    Popcorn.p[ method ] = function( plugin ) {

      return Popcorn[ method ]( this, plugin );

    };

  });

  Popcorn.extend(Popcorn.p, {