/*!
 * imagesloaded v3.0.2
 * javascript is all like "you images are done yet or what?"
 */

( function( window ) {

'use strict';

var $ = window.jquery;
var console = window.console;
var hasconsole = typeof console !== 'undefined';

// -------------------------- helpers -------------------------- //

// extend objects
function extend( a, b ) {
  for ( var prop in b ) {
    a[ prop ] = b[ prop ];
  }
  return a;
}

var objtostring = object.prototype.tostring;
function isarray( obj ) {
  return objtostring.call( obj ) === '[object array]';
}

// turn element or nodelist into an array
function makearray( obj ) {
  var ary = [];
  if ( isarray( obj ) ) {
    // use object if already an array
    ary = obj;
  } else if ( typeof obj.length === 'number' ) {
    // convert nodelist to array
    for ( var i=0, len = obj.length; i < len; i++ ) {
      ary.push( obj[i] );
    }
  } else {
    // array of single index
    ary.push( obj );
  }
  return ary;
}

// --------------------------  -------------------------- //

function defineimagesloaded( eventemitter, eventie ) {

  /**
   * @param {array, element, nodelist, string} elem
   * @param {object or function} options - if function, use as callback
   * @param {function} onalways - callback function
   */
  function imagesloaded( elem, options, onalways ) {
    // coerce imagesloaded() without new, to be new imagesloaded()
    if ( !( this instanceof imagesloaded ) ) {
      return new imagesloaded( elem, options );
    }
    // use elem as selector string
    if ( typeof elem === 'string' ) {
      elem = document.queryselectorall( elem );
    }

    this.elements = makearray( elem );
    this.options = extend( {}, this.options );

    if ( typeof options === 'function' ) {
      onalways = options;
    } else {
      extend( this.options, options );
    }

    if ( onalways ) {
      this.on( 'always', onalways );
    }

    this.getimages();

    if ( $ ) {
      // add jquery deferred object
      this.jqdeferred = new $.deferred();
    }

    // hack check async to allow time to bind listeners
    var _this = this;
    settimeout( function() {
      _this.check();
    });
  }

  imagesloaded.prototype = new eventemitter();

  imagesloaded.prototype.options = {};

  imagesloaded.prototype.getimages = function() {
    this.images = [];

    // filter & find items if we have an item selector
    for ( var i=0, len = this.elements.length; i < len; i++ ) {
      var elem = this.elements[i];
      // filter siblings
      if ( elem.nodename === 'img' ) {
        this.addimage( elem );
      }
      // find children
      var childelems = elem.queryselectorall('img');
      // concat childelems to filterfound array
      for ( var j=0, jlen = childelems.length; j < jlen; j++ ) {
        var img = childelems[j];
        this.addimage( img );
      }
    }
  };

  /**
   * @param {image} img
   */
  imagesloaded.prototype.addimage = function( img ) {
    var loadingimage = new loadingimage( img );
    this.images.push( loadingimage );
  };

  imagesloaded.prototype.check = function() {
    var _this = this;
    var checkedcount = 0;
    var length = this.images.length;
    this.hasanybroken = false;
    // complete if no images
    if ( !length ) {
      this.complete();
      return;
    }

    function onconfirm( image, message ) {
      if ( _this.options.debug && hasconsole ) {
        console.log( 'confirm', image, message );
      }

      _this.progress( image );
      checkedcount++;
      if ( checkedcount === length ) {
        _this.complete();
      }
      return true; // bind once
    }

    for ( var i=0; i < length; i++ ) {
      var loadingimage = this.images[i];
      loadingimage.on( 'confirm', onconfirm );
      loadingimage.check();
    }
  };

  imagesloaded.prototype.progress = function( image ) {
    this.hasanybroken = this.hasanybroken || !image.isloaded;
    this.emit( 'progress', this, image );
    if ( this.jqdeferred ) {
      this.jqdeferred.notify( this, image );
    }
  };

  imagesloaded.prototype.complete = function() {
    var eventname = this.hasanybroken ? 'fail' : 'done';
    this.iscomplete = true;
    this.emit( eventname, this );
    this.emit( 'always', this );
    if ( this.jqdeferred ) {
      var jqmethod = this.hasanybroken ? 'reject' : 'resolve';
      this.jqdeferred[ jqmethod ]( this );
    }
  };

  // -------------------------- jquery -------------------------- //

  if ( $ ) {
    $.fn.imagesloaded = function( options, callback ) {
      var instance = new imagesloaded( this, options, callback );
      return instance.jqdeferred.promise( $(this) );
    };
  }


  // --------------------------  -------------------------- //

  var cache = {};

  function loadingimage( img ) {
    this.img = img;
  }

  loadingimage.prototype = new eventemitter();

  loadingimage.prototype.check = function() {
    // first check cached any previous images that have same src
    var cached = cache[ this.img.src ];
    if ( cached ) {
      this.usecached( cached );
      return;
    }
    // add this to cache
    cache[ this.img.src ] = this;

    // if complete is true and browser supports natural sizes,
    // try to check for image status manually.
    if ( this.img.complete && this.img.naturalwidth !== undefined ) {
      // report based on naturalwidth
      this.confirm( this.img.naturalwidth !== 0, 'naturalwidth' );
      return;
    }

    // if none of the checks above matched, simulate loading on detached element.
    var proxyimage = this.proxyimage = new image();
    eventie.bind( proxyimage, 'load', this );
    eventie.bind( proxyimage, 'error', this );
    proxyimage.src = this.img.src;
  };

  loadingimage.prototype.usecached = function( cached ) {
    if ( cached.isconfirmed ) {
      this.confirm( cached.isloaded, 'cached was confirmed' );
    } else {
      var _this = this;
      cached.on( 'confirm', function( image ) {
        _this.confirm( image.isloaded, 'cache emitted confirmed' );
        return true; // bind once
      });
    }
  };

  loadingimage.prototype.confirm = function( isloaded, message ) {
    this.isconfirmed = true;
    this.isloaded = isloaded;
    this.emit( 'confirm', this, message );
  };

  // trigger specified handler for event type
  loadingimage.prototype.handleevent = function( event ) {
    var method = 'on' + event.type;
    if ( this[ method ] ) {
      this[ method ]( event );
    }
  };

  loadingimage.prototype.onload = function() {
    this.confirm( true, 'onload' );
    this.unbindproxyevents();
  };

  loadingimage.prototype.onerror = function() {
    this.confirm( false, 'onerror' );
    this.unbindproxyevents();
  };

  loadingimage.prototype.unbindproxyevents = function() {
    eventie.unbind( this.proxyimage, 'load', this );
    eventie.unbind( this.proxyimage, 'error', this );
  };

  // -----  ----- //

  return imagesloaded;
}

// -------------------------- transport -------------------------- //

if ( typeof define === 'function' && define.amd ) {
  // amd
  define( [
      'eventemitter',
      'eventie'
    ],
    defineimagesloaded );
} else {
  // browser global
  window.imagesloaded = defineimagesloaded(
    window.eventemitter,
    window.eventie
  );
}

})( window );