/* global pluploadL10n, plupload, _wpPluploadSettings */

/**

 * @namespace wp

 */

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

	 * WordPress back end and the WordPress media experience.

	 *

	 * @class

	 * @memberOf wp

	 * @alias wp.Uploader

	 *

	 * @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, // Not used, back-compat.

			elements = {

				container: 'container',

				browser:   'browse_button',

				dropzone:  'drop_element'

			},

			tryAgainCount = {},

			tryAgain,

			key,

			error,

			fileUploaded;

		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 ( typeof this[ key ] === 'function' ) {

				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;

		}

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

		/**

		 * Attempt to create image sub-sizes when an image was uploaded successfully

		 * but the server responded with HTTP 5xx error.

		 *

		 * @since 5.3.0

		 *

		 * @param {string}        message Error message.

		 * @param {object}        data    Error data from Plupload.

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

		 */

		tryAgain = function( message, data, file ) {

			var times, id;

			if ( ! data || ! data.responseHeaders ) {

				error( pluploadL10n.http_error_image, data, file, 'no-retry' );

				return;

			}

			id = data.responseHeaders.match( /x-wp-upload-attachment-id:\s*(\d+)/i );

			if ( id && id[1] ) {

				id = id[1];

			} else {

				error( pluploadL10n.http_error_image, data, file, 'no-retry' );

				return;

			}

			times = tryAgainCount[ file.id ];

			if ( times && times > 4 ) {

				/*

				 * The file may have been uploaded and attachment post created,

				 * but post-processing and resizing failed...

				 * Do a cleanup then tell the user to scale down the image and upload it again.

				 */

				$.ajax({

					type: 'post',

					url: ajaxurl,

					dataType: 'json',

					data: {

						action: 'media-create-image-subsizes',

						_wpnonce: _wpPluploadSettings.defaults.multipart_params._wpnonce,

						attachment_id: id,

						_wp_upload_failed_cleanup: true,

					}

				});

				error( message, data, file, 'no-retry' );

				return;

			}

			if ( ! times ) {

				tryAgainCount[ file.id ] = 1;

			} else {

				tryAgainCount[ file.id ] = ++times;

			}

			// Another request to try to create the missing image sub-sizes.

			$.ajax({

				type: 'post',

				url: ajaxurl,

				dataType: 'json',

				data: {

					action: 'media-create-image-subsizes',

					_wpnonce: _wpPluploadSettings.defaults.multipart_params._wpnonce,

					attachment_id: id,

				}

			}).done( function( response ) {

				if ( response.success ) {

					fileUploaded( self.uploader, file, response );

				} else {

					if ( response.data && response.data.message ) {

						message = response.data.message;

					}

					error( message, data, file, 'no-retry' );

				}

			}).fail( function( jqXHR ) {

				// If another HTTP 5xx error, try try again...

				if ( jqXHR.status >= 500 && jqXHR.status < 600 ) {

					tryAgain( message, data, file );

					return;

				}

				error( message, data, file, 'no-retry' );

			});

		}

		/**

		 * 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 Error message.

		 * @param {object}        data    Error data from Plupload.

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

		 * @param {string}        retry   Whether to try again to create image sub-sizes. Passing 'no-retry' will prevent it.

		 */

		error = function( message, data, file, retry ) {

			var isImage = file.type && file.type.indexOf( 'image/' ) === 0,

				status = data && data.status;

			// If the file is an image and the error is HTTP 5xx try to create sub-sizes again.

			if ( retry !== 'no-retry' && isImage && status >= 500 && status < 600 ) {

				tryAgain( message, data, file );

				return;

			}

			if ( file.attachment ) {

				file.attachment.destroy();

			}

			Uploader.errors.unshift({

				message: message || pluploadL10n.default_error,

				data:    data,

				file:    file

			});

			self.error( message, data, file );

		};

		/**

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

		 *

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

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

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

		 */

		fileUploaded = function( up, file, response ) {

			var complete;

			// Remove the "uploading" UI elements.

			_.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 );

		}

		/**

		 * 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.on( 'dragover.wp-uploader', function() {

				if ( timer ) {

					clearTimeout( timer );

				}

				if ( active ) {

					return;

				}

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

				active = true;

			});

			dropzone.on('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.bind( 'postinit', function( up ) {

			up.refresh();

			self.init();

		});

		this.uploader.init();

		if ( this.browser ) {

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

		} else {

			this.uploader.disableBrowse( true );

		}

		$( self ).on( 'uploader:ready', function() {

			$( '.moxie-shim-html5 input[type="file"]' )

				.attr( {

					tabIndex:      '-1',

					'aria-hidden': 'true'

				} );

		} );

		/**

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

		 *

		 * @param {plupload.Uploader} up    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;

				}

				if ( file.type === 'image/heic' && up.settings.heic_upload_error ) {

					// Show error but do not block uploading.

					Uploader.errors.unshift({

						message: pluploadL10n.unsupported_image,

						data:    {},

						file:    file

					});

				} else if ( file.type === 'image/webp' && up.settings.webp_upload_error ) {

					// Disallow uploading of WebP images if the server cannot edit them.

					error( pluploadL10n.noneditable_image, {}, file, 'no-retry' );