/* global pluploadL10n, plupload, _wpPluploadSettings */

window.wp = window.wp || {};

( function( exports, $ ) {

	var Uploader;

	if ( typeof _wpPluploadSettings === 'undefined' ) {

		return;

	}

	/**

	 * A WordPress uploader.

	 *

	 * The Plupload library provides cross-browser uploader UI integration.

	 * This object bridges the Plupload API to integrate uploads into the

	 *

	 * @param {object} options           The options passed to the new plupload instance.

	 * @param {object} options.container The id of uploader container.

	 * @param {object} options.browser   The id of button to trigger the file select.

	 * @param {object} options.dropzone  The id of file drop target.

	 * @param {object} options.plupload  An object of parameters to pass to the plupload instance.

	 * @param {object} options.params    An object of parameters to pass to $_POST when uploading the file.

	 *                                   Extends this.plupload.multipart_params under the hood.

	 */

	Uploader = function( options ) {

		var self = this,

			isIE = navigator.userAgent.indexOf('Trident/') != -1 || navigator.userAgent.indexOf('MSIE ') != -1,

			elements = {

				container: 'container',

				browser:   'browse_button',

				dropzone:  'drop_element'

			},

			key, error;

		this.supports = {

			upload: Uploader.browser.supported

		};

		this.supported = this.supports.upload;

		if ( ! this.supported ) {

			return;

		}

		// Arguments to send to pluplad.Uploader().

		// Use deep extend to ensure that multipart_params and other objects are cloned.

		this.plupload = $.extend( true, { multipart_params: {} }, Uploader.defaults );

		this.container = document.body; // Set default container.

		// Extend the instance with options.

		//

		// Use deep extend to allow options.plupload to override individual

		// default plupload keys.

		$.extend( true, this, options );

		// Proxy all methods so this always refers to the current instance.

		for ( key in this ) {

			if ( $.isFunction( this[ key ] ) ) {

				this[ key ] = $.proxy( this[ key ], this );

			}

		}

		// Ensure all elements are jQuery elements and have id attributes,

		// then set the proper plupload arguments to the ids.

		for ( key in elements ) {

			if ( ! this[ key ] ) {

				continue;

			}

			this[ key ] = $( this[ key ] ).first();

			if ( ! this[ key ].length ) {

				delete this[ key ];

				continue;

			}

			if ( ! this[ key ].prop('id') ) {

				this[ key ].prop( 'id', '__wp-uploader-id-' + Uploader.uuid++ );

			}

			this.plupload[ elements[ key ] ] = this[ key ].prop('id');

		}

		// If the uploader has neither a browse button nor a dropzone, bail.

		if ( ! ( this.browser && this.browser.length ) && ! ( this.dropzone && this.dropzone.length ) ) {

			return;

		}

		// Make sure flash sends cookies (seems in IE it does without switching to urlstream mode)

		if ( ! isIE && 'flash' === plupload.predictRuntime( this.plupload ) &&

			( ! this.plupload.required_features || ! this.plupload.required_features.hasOwnProperty( 'send_binary_string' ) ) ) {

			this.plupload.required_features = this.plupload.required_features || {};

			this.plupload.required_features.send_binary_string = true;

		}

		// Initialize the plupload instance.

		this.uploader = new plupload.Uploader( this.plupload );

		delete this.plupload;

		// Set default params and remove this.params alias.

		this.param( this.params || {} );

		delete this.params;

		/**

		 * Custom error callback.

		 *

		 * Add a new error to the errors collection, so other modules can track

		 * and display errors. @see wp.Uploader.errors.

		 *

		 * @param  {string}        message

		 * @param  {object}        data

		 * @param  {plupload.File} file     File that was uploaded.

		 */

		error = function( message, data, file ) {

			if ( file.attachment ) {

				file.attachment.destroy();

			}

			Uploader.errors.unshift({

				message: message || pluploadL10n.default_error,

				data:    data,

				file:    file

			});

			self.error( message, data, file );

		};

		/**

		 * After the Uploader has been initialized, initialize some behaviors for the dropzone.

		 *

		 * @param {plupload.Uploader} uploader Uploader instance.

		 */

		this.uploader.bind( 'init', function( uploader ) {

			var timer, active, dragdrop,

				dropzone = self.dropzone;

			dragdrop = self.supports.dragdrop = uploader.features.dragdrop && ! Uploader.browser.mobile;

			// Generate drag/drop helper classes.

			if ( ! dropzone ) {

				return;

			}

			dropzone.toggleClass( 'supports-drag-drop', !! dragdrop );

			if ( ! dragdrop ) {

				return dropzone.unbind('.wp-uploader');

			}

			// 'dragenter' doesn't fire correctly, simulate it with a limited 'dragover'.

			dropzone.bind( 'dragover.wp-uploader', function() {

				if ( timer ) {

					clearTimeout( timer );

				}

				if ( active ) {

					return;

				}

				dropzone.trigger('dropzone:enter').addClass('drag-over');

				active = true;

			});

			dropzone.bind('dragleave.wp-uploader, drop.wp-uploader', function() {

				// Using an instant timer prevents the drag-over class from

				// being quickly removed and re-added when elements inside the

				// dropzone are repositioned.

				//

				// @see https://core.trac.wordpress.org/ticket/21705

				timer = setTimeout( function() {

					active = false;

					dropzone.trigger('dropzone:leave').removeClass('drag-over');

				}, 0 );

			});

			self.ready = true;

			$(self).trigger( 'uploader:ready' );

		});

		this.uploader.init();

		if ( this.browser ) {

			this.browser.on( 'mouseenter', this.refresh );

		} else {

			this.uploader.disableBrowse( true );

			// If HTML5 mode, hide the auto-created file container.

			$('#' + this.uploader.id + '_html5_container').hide();

		}

		/**

		 * After files were filtered and added to the queue, create a model for each.

		 *

		 * @param {plupload.Uploader} uploader Uploader instance.

		 * @param {Array}             files    Array of file objects that were added to queue by the user.

		 */

		this.uploader.bind( 'FilesAdded', function( up, files ) {

			_.each( files, function( file ) {

				var attributes, image;

				// Ignore failed uploads.

				if ( plupload.FAILED === file.status ) {

					return;

				}

				// Generate attributes for a new `Attachment` model.

				attributes = _.extend({

					file:      file,

					uploading: true,

					date:      new Date(),

					filename:  file.name,

					menuOrder: 0,

					uploadedTo: wp.media.model.settings.post.id

				}, _.pick( file, 'loaded', 'size', 'percent' ) );

				// Handle early mime type scanning for images.

				image = /(?:jpe?g|png|gif)$/i.exec( file.name );

				// For images set the model's type and subtype attributes.

				if ( image ) {

					attributes.type = 'image';

					// `jpeg`, `png` and `gif` are valid subtypes.

					// `jpg` is not, so map it to `jpeg`.

					attributes.subtype = ( 'jpg' === image[0] ) ? 'jpeg' : image[0];

				}

				// Create a model for the attachment, and add it to the Upload queue collection

				// so listeners to the upload queue can track and display upload progress.

				file.attachment = wp.media.model.Attachment.create( attributes );

				Uploader.queue.add( file.attachment );

				self.added( file.attachment );

			});

			up.refresh();

			up.start();

		});

		this.uploader.bind( 'UploadProgress', function( up, file ) {

			file.attachment.set( _.pick( file, 'loaded', 'percent' ) );

			self.progress( file.attachment );

		});

		/**

		 * After a file is successfully uploaded, update its model.

		 *

		 * @param {plupload.Uploader} uploader Uploader instance.

		 * @param {plupload.File}     file     File that was uploaded.

		 * @param {Object}            response Object with response properties.

		 * @return {mixed}

		 */

		this.uploader.bind( 'FileUploaded', function( up, file, response ) {

			var complete;

			try {

				response = JSON.parse( response.response );

			} catch ( e ) {

				return error( pluploadL10n.default_error, e, file );

			}

			if ( ! _.isObject( response ) || _.isUndefined( response.success ) )

				return error( pluploadL10n.default_error, null, file );

			else if ( ! response.success )

				return error( response.data && response.data.message, response.data, file );

			_.each(['file','loaded','size','percent'], function( key ) {

				file.attachment.unset( key );

			});

			file.attachment.set( _.extend( response.data, { uploading: false }) );

			wp.media.model.Attachment.get( response.data.id, file.attachment );

			complete = Uploader.queue.all( function( attachment ) {

				return ! attachment.get('uploading');

			});

			if ( complete )

				Uploader.queue.reset();

			self.success( file.attachment );

		});

		/**

		 * When plupload surfaces an error, send it to the error handler.

		 *

		 * @param {plupload.Uploader} uploader Uploader instance.

		 * @param {Object}            error    Contains code, message and sometimes file and other details.

		 */

		this.uploader.bind( 'Error', function( up, pluploadError ) {

			var message = pluploadL10n.default_error,

				key;

			// Check for plupload errors.

			for ( key in Uploader.errorMap ) {

				if ( pluploadError.code === plupload[ key ] ) {

					message = Uploader.errorMap[ key ];

					if ( _.isFunction( message ) ) {

						message = message( pluploadError.file, pluploadError );

					}

					break;

				}

			}

			error( message, pluploadError, pluploadError.file );

			up.refresh();

		});

	};

	// Adds the 'defaults' and 'browser' properties.

	$.extend( Uploader, _wpPluploadSettings );

	Uploader.uuid = 0;

	// Map Plupload error codes to user friendly error messages.

	Uploader.errorMap = {

		'FAILED':                 pluploadL10n.upload_failed,

		'FILE_EXTENSION_ERROR':   pluploadL10n.invalid_filetype,

		'IMAGE_FORMAT_ERROR':     pluploadL10n.not_an_image,

		'IMAGE_MEMORY_ERROR':     pluploadL10n.image_memory_exceeded,

		'IMAGE_DIMENSIONS_ERROR': pluploadL10n.image_dimensions_exceeded,

		'GENERIC_ERROR':          pluploadL10n.upload_failed,

		'IO_ERROR':               pluploadL10n.io_error,

		'HTTP_ERROR':             pluploadL10n.http_error,

		'SECURITY_ERROR':         pluploadL10n.security_error,

		'FILE_SIZE_ERROR': function( file ) {

			return pluploadL10n.file_exceeds_size_limit.replace('%s', file.name);

		}

	};

		/**

		 * Acts as a shortcut to extending the uploader's multipart_params object.

		 *

		 * param( key )

		 *    Returns the value of the key.

		 *

		 * param( key, value )

		 *    Sets the value of a key.

		 *

		 * param( map )

		 *    Sets values for a map of data.

		 */

		param: function( key, value ) {

			if ( arguments.length === 1 && typeof key === 'string' ) {

				return this.uploader.settings.multipart_params[ key ];

			}

			if ( arguments.length > 1 ) {

				this.uploader.settings.multipart_params[ key ] = value;