/*

 * popcorn.js version 1.3

 * http://popcornjs.org

 *

 * Copyright 2011, Mozilla Foundation

 * Licensed under the MIT license

 */

(function(global, document) {

  // Popcorn.js does not support archaic browsers

  if ( !document.addEventListener ) {

    global.Popcorn = {

      isSupported: false

    };

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

          "addTrackEvent removeTrackEvent getTrackEvents getTrackEvent getLastTrackEventId " +

          "timeUpdate plugin removePlugin compose effect 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,

  //  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 );

      };

  }()),

  //  Non-public `getKeys`, return an object's keys as an array

  getKeys = function( obj ) {

    return Object.keys ? Object.keys( obj ) : (function( obj ) {

      var item,

          list = [];

      for ( item in obj ) {

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

          list.push( item );

        }

      }

      return list;

    })( obj );

  },

  //  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 = "1.3";

  //  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, nodeName,

          self = this;

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

      //  Originally proposed by Daniel Brooks

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

        //  If document ready has already fired

        if ( 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;

      }

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

        try {

          matches = document.querySelector( entity );

        } catch( e ) {

          throw new Error( "Popcorn.js Error: Invalid media element selector: " + entity );

        }

      }

      //  Get media element by id or object reference

      this.media = matches || entity;

      //  inner reference to this media element's nodeName string value

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

      //  Create an audio or video element property reference

      this[ nodeName ] = this.media;

      this.options = options || {};

      //  Resolve custom ID or default prefixed ID

      this.id = this.options.id || Popcorn.guid( nodeName );

      //  Throw if an attempt is made to use an ID that already exists

      if ( Popcorn.byId( this.id ) ) {

        throw new Error( "Popcorn.js Error: Cannot use duplicate ID (" + this.id + ")" );

      }

      this.isDestroyed = false;

      this.data = {

        // data structure of all

        running: {

          cue: []

        },

        // 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

        }

      };

      //  Register new instance

      Popcorn.instances.push( this );

      //  function to fire when video is ready

      var isReady = function() {

        // chrome bug: http://code.google.com/p/chromium/issues/detail?id=119598

        // it is possible the video's time is less than 0

        // this has the potential to call track events more than once, when they should not

        // start: 0, end: 1 will start, end, start again, when it should just start

        // just setting it to 0 if it is below 0 fixes this issue

        if ( self.media.currentTime < 0 ) {

          self.media.currentTime = 0;

        }

        self.media.removeEventListener( "loadeddata", isReady, false );

        var duration, videoDurationPlus,

            runningPlugins, runningPlugin, rpLength, rpNatives;

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

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

        duration = self.media.duration;

        //  Check for no duration info (NaN)

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

        Popcorn.addTrackEvent( self, {

          start: videoDurationPlus,

          end: videoDurationPlus

        });

        if ( self.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)

          self.data.timeUpdate = function () {

            Popcorn.timeUpdate( self, {} );

            // fire frame for each enabled active plugin of every type

            Popcorn.forEach( Popcorn.manifest, function( key, val ) {

              runningPlugins = self.data.running[ val ];

              // ensure there are running plugins on this type on this instance

              if ( runningPlugins ) {

                rpLength = runningPlugins.length;

                for ( var i = 0; i < rpLength; i++ ) {

                  runningPlugin = runningPlugins[ i ];

                  rpNatives = runningPlugin._natives;

                  rpNatives && rpNatives.frame &&

                    rpNatives.frame.call( self, {}, runningPlugin, self.currentTime() );

                }

              }

            });

            self.emit( "timeupdate" );

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

          };

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

        } else {

          self.data.timeUpdate = function( event ) {

            Popcorn.timeUpdate( self, event );

          };

          if ( !self.isDestroyed ) {

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

          }

        }

      };

      Object.defineProperty( this, "error", {

        get: function() {

          return self.media.error;

        }

      });

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

        isReady();

      } else {

        self.media.addEventListener( "loadeddata", isReady, false );

      }

      return this;

    }

  };

  //  Extend constructor prototype to instance prototype

  //  Allows chaining methods to instances

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

  Popcorn.byId = function( str ) {

    var instances = Popcorn.instances,

        length = instances.length,

        i = 0;

    for ( ; i < length; i++ ) {

      if ( instances[ i ].id === str ) {

        return instances[ i ];

      }

    }

    return null;

  };

  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 ) {

      if ( !instance.data.disabled[ plugin ] ) {

        instance.data.disabled[ plugin ] = true;

        for ( var i = instance.data.running[ plugin ].length - 1, event; i >= 0; i-- ) {

          event = instance.data.running[ plugin ][ i ];

          event._natives.end.call( instance, null, event  );

        }

      }

      return instance;

    },

    enable: function( instance, plugin ) {

      if ( instance.data.disabled[ plugin ] ) {

        instance.data.disabled[ plugin ] = false;

        for ( var i = instance.data.running[ plugin ].length - 1, event; i >= 0; i-- ) {

          event = instance.data.running[ plugin ][ i ];

          event._natives.start.call( instance, null, event  );

        }

      }

      return instance;

    },

    destroy: function( instance ) {

      var events = instance.data.events,

          trackEvents = instance.data.trackEvents,

          singleEvent, item, fn, plugin;

      //  Iterate through all events and remove them

      for ( item in events ) {

        singleEvent = events[ item ];

        for ( fn in singleEvent ) {

          delete singleEvent[ fn ];

        }

        events[ item ] = null;

      }

      // remove all plugins off the given instance

      for ( plugin in Popcorn.registryByName ) {

        Popcorn.removePlugin( instance, plugin );

      }

      // Remove all data.trackEvents #1178

      trackEvents.byStart.length = 0;

      trackEvents.byEnd.length = 0;

      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 ) {

          var previous;

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