/*
 ### jQuery Multiple File Upload Plugin v1.47 - 2010-03-26 ###
 * Home: http://www.fyneworks.com/jquery/multiple-file-upload/
 * Code: http://code.google.com/p/jquery-multifile-plugin/
 *
 * Dual licensed under the MIT and GPL licenses:
 *   http://www.opensource.org/licenses/mit-license.php
 *   http://www.gnu.org/licenses/gpl.html
 ###
*/

/*# AVOID COLLISIONS #*/
;
if(window.jQuery) (function($){
    /*# AVOID COLLISIONS #*/

    // plugin initialization
    $.fn.MultiFile = function(options){
        if(this.length==0) return this; // quick fail

        // Handle API methods
        if(typeof arguments[0]=='string'){
            // Perform API methods on individual elements
            if(this.length>1){
                var args = arguments;
                return this.each(function(){
                    $.fn.MultiFile.apply($(this), args);
                });
            };
            // Invoke API method handler
            $.fn.MultiFile[arguments[0]].apply(this, $.makeArray(arguments).slice(1) || []);
            // Quick exit...
            return this;
        };

        // Initialize options for this call
        var options = $.extend(
        {}/* new object */,
            $.fn.MultiFile.options/* default options */,
            options || {} /* just-in-time options */
            );

        // Empty Element Fix!!!
        // this code will automatically intercept native form submissions
        // and disable empty file elements
        $('form')
        .not('MultiFile-intercepted')
        .addClass('MultiFile-intercepted')
        .submit($.fn.MultiFile.disableEmpty);

        //### http://plugins.jquery.com/node/1363
        // utility method to integrate this plugin with others...
        if($.fn.MultiFile.options.autoIntercept){
            $.fn.MultiFile.intercept( $.fn.MultiFile.options.autoIntercept /* array of methods to intercept */ );
            $.fn.MultiFile.options.autoIntercept = null; /* only run this once */
        };

        // loop through each matched element
        this
        .not('.MultiFile-applied')
        .addClass('MultiFile-applied')
        .each(function(){
            //#####################################################################
            // MAIN PLUGIN FUNCTIONALITY - START
            //#####################################################################

            // BUG 1251 FIX: http://plugins.jquery.com/project/comments/add/1251
            // variable group_count would repeat itself on multiple calls to the plugin.
            // this would cause a conflict with multiple elements
            // changes scope of variable to global so id will be unique over n calls
            window.MultiFile = (window.MultiFile || 0) + 1;
            var group_count = window.MultiFile;

            // Copy parent attributes - Thanks to Jonas Wagner
            // we will use this one to create new input elements
            var MultiFile = {
                e:this,
                E:$(this),
                clone:$(this).clone()
                };

            //===

            //# USE CONFIGURATION
            if(typeof options=='number') options = {
                max:options
            };
            var o = $.extend({},
                $.fn.MultiFile.options,
                options || {},
                ($.metadata? MultiFile.E.metadata(): ($.meta?MultiFile.E.data():null)) || {}, /* metadata options */
                {} /* internals */
                );
            // limit number of files that can be selected?
            if(!(o.max>0) /*IsNull(MultiFile.max)*/){
                o.max = MultiFile.E.attr('maxlength');
                if(!(o.max>0) /*IsNull(MultiFile.max)*/){
                    o.max = (String(MultiFile.e.className.match(/\b(max|limit)\-([0-9]+)\b/gi) || ['']).match(/[0-9]+/gi) || [''])[0];
                    if(!(o.max>0)) o.max = -1;
                    else           o.max = String(o.max).match(/[0-9]+/gi)[0];
                }
            };
            o.max = new Number(o.max);
            // limit extensions?
            o.accept = o.accept || MultiFile.E.attr('accept') || '';
            if(!o.accept){
                o.accept = (MultiFile.e.className.match(/\b(accept\-[\w\|]+)\b/gi)) || '';
                o.accept = new String(o.accept).replace(/^(accept|ext)\-/i,'');
            };

            //===

            // APPLY CONFIGURATION
            $.extend(MultiFile, o || {});
            MultiFile.STRING = $.extend({},$.fn.MultiFile.options.STRING,MultiFile.STRING);

            //===

            //#########################################
            // PRIVATE PROPERTIES/METHODS
            $.extend(MultiFile, {
                n: 0, // How many elements are currently selected?
                slaves: [],
                files: [],
                instanceKey: MultiFile.e.id || 'MultiFile'+String(group_count), // Instance Key?
                generateID: function(z){
                    return MultiFile.instanceKey + (z>0 ?'_F'+String(z):'');
                },
                trigger: function(event, element){
                    var handler = MultiFile[event], value = $(element).attr('value');
                    if(handler){
                        var returnValue = handler(element, value, MultiFile);
                        if( returnValue!=null ) return returnValue;
                    }
                    return true;
                }
            });

            //===

            // Setup dynamic regular expression for extension validation
            // - thanks to John-Paul Bader: http://smyck.de/2006/08/11/javascript-dynamic-regular-expresions/
            if(String(MultiFile.accept).length>1){
                MultiFile.accept = MultiFile.accept.replace(/\W+/g,'|').replace(/^\W|\W$/g,'');
                MultiFile.rxAccept = new RegExp('\\.('+(MultiFile.accept?MultiFile.accept:'')+')$','gi');
            };

            //===

            // Create wrapper to hold our file list
            MultiFile.wrapID = MultiFile.instanceKey+'_wrap'; // Wrapper ID?
            MultiFile.E.wrap('<div class="MultiFile-wrap" id="'+MultiFile.wrapID+'"></div>');
            MultiFile.wrapper = $('#'+MultiFile.wrapID+'');

            //===

            // MultiFile MUST have a name - default: file1[], file2[], file3[]
            MultiFile.e.name = MultiFile.e.name || 'file'+ group_count +'[]';

            //===

            if(!MultiFile.list){
                // Create a wrapper for the list
                // * OPERA BUG: NO_MODIFICATION_ALLOWED_ERR ('list' is a read-only property)
                // this change allows us to keep the files in the order they were selected
                MultiFile.wrapper.append( '<div class="MultiFile-list" id="'+MultiFile.wrapID+'_list"></div>' );
                MultiFile.list = $('#'+MultiFile.wrapID+'_list');
            };
            MultiFile.list = $(MultiFile.list);

            //===

            // Bind a new element
            MultiFile.addSlave = function( slave, slave_count ){
                //if(window.console) console.log('MultiFile.addSlave',slave_count);

                // Keep track of how many elements have been displayed
                MultiFile.n++;
                // Add reference to master element
                slave.MultiFile = MultiFile;

                // BUG FIX: http://plugins.jquery.com/node/1495
                // Clear identifying properties from clones
                if(slave_count>0) slave.id = slave.name = '';

                // Define element's ID and name (upload components need this!)
                //slave.id = slave.id || MultiFile.generateID(slave_count);
                if(slave_count>0) slave.id = MultiFile.generateID(slave_count);
                //FIX for: http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=23

                // 2008-Apr-29: New customizable naming convention (see url below)
                // http://groups.google.com/group/jquery-dev/browse_frm/thread/765c73e41b34f924#
                slave.name = String(MultiFile.namePattern
                    /*master name*/.replace(/\$name/gi,$(MultiFile.clone).attr('name'))
                    /*master id  */.replace(/\$id/gi,  $(MultiFile.clone).attr('id'))
                    /*group count*/.replace(/\$g/gi,   group_count)//(group_count>0?group_count:''))
                    /*slave count*/.replace(/\$i/gi,   slave_count)//(slave_count>0?slave_count:''))
                    );

                // If we've reached maximum number, disable input slave
                if( (MultiFile.max > 0) && ((MultiFile.n-1) > (MultiFile.max)) )//{ // MultiFile.n Starts at 1, so subtract 1 to find true count
                    slave.disabled = true;
                //};

                // Remember most recent slave
                MultiFile.current = MultiFile.slaves[slave_count] = slave;

                // We'll use jQuery from now on
                slave = $(slave);

                // Clear value
                slave.val('').attr('value','')[0].value = '';

                // Stop plugin initializing on slaves
                slave.addClass('MultiFile-applied');

                // Triggered when a file is selected
                slave.change(function(){
                    //if(window.console) console.log('MultiFile.slave.change',slave_count);

                    // Lose focus to stop IE7 firing onchange again
                    $(this).blur();

                    //# Trigger Event! onFileSelect
                    if(!MultiFile.trigger('onFileSelect', this, MultiFile)) return false;
                    //# End Event!

                    //# Retrive value of selected file from element
                    var ERROR = '', v = String(this.value || ''/*.attr('value)*/);

                    // check extension
                    if(MultiFile.accept && v && !v.match(MultiFile.rxAccept))//{
                        ERROR = MultiFile.STRING.denied.replace('$ext', String(v.match(/\.\w{1,4}$/gi)));
                    //}
                    //};

                    // Disallow duplicates
                    for(var f in MultiFile.slaves)//{
                        if(MultiFile.slaves[f] && MultiFile.slaves[f]!=this)//{
                            //console.log(MultiFile.slaves[f],MultiFile.slaves[f].value);
                            if(MultiFile.slaves[f].value==v)//{
                                ERROR = MultiFile.STRING.duplicate.replace('$file', v.match(/[^\/\\]+$/gi));
                    //};
                    //};
                    //};

                    // Create a new file input element
                    var newEle = $(MultiFile.clone).clone();// Copy parent attributes - Thanks to Jonas Wagner
                    //# Let's remember which input we've generated so
                    // we can disable the empty ones before submission
                    // See: http://plugins.jquery.com/node/1495
                    newEle.addClass('MultiFile');

                    // Handle error
                    if(ERROR!=''){
                        // Handle error
                        MultiFile.error(ERROR);

                        // 2007-06-24: BUG FIX - Thanks to Adrian Wróbel <adrian [dot] wrobel [at] gmail.com>
                        // Ditch the trouble maker and add a fresh new element
                        MultiFile.n--;
                        MultiFile.addSlave(newEle[0], slave_count);
                        slave.parent().prepend(newEle);
                        slave.remove();
                        return false;
                    };

                    // Hide this element (NB: display:none is evil!)
                    $(this).css({
                        position:'absolute',
                        top: '-3000px'
                    });
          

                    // Add new element to the form
                    slave.after(newEle);

                    // Update list
                    MultiFile.addToList( this, slave_count );

                    // Bind functionality
                    MultiFile.addSlave( newEle[0], slave_count+1 );

                    //# Trigger Event! afterFileSelect
                    if(!MultiFile.trigger('afterFileSelect', this, MultiFile)) return false;
                //# End Event!

                }); // slave.change()

                // Save control to element
                $(slave).data('MultiFile', MultiFile);

                
            };// MultiFile.addSlave
            // Bind a new element



            // Add a new file to the list
            MultiFile.addToList = function( slave, slave_count ){
                //if(window.console) console.log('MultiFile.addToList',slave_count);

                //# Trigger Event! onFileAppend
                if(!MultiFile.trigger('onFileAppend', slave, MultiFile)) return false;
                //# End Event!

                // Create label elements
                var
                r = $('<div class="MultiFile-label"></div>'),
                v = String(slave.value || ''/*.attr('value)*/),
                a = $('<span class="MultiFile-title" title="'+MultiFile.STRING.selected.replace('$file', v)+'">'+MultiFile.STRING.file.replace('$file', v.match(/[^\/\\]+$/gi)[0])+'</span>'),
                b = $('<a class="MultiFile-remove" href="#'+MultiFile.wrapID+'">'+MultiFile.STRING.remove+'</a>');

                // Insert label
                MultiFile.list.append(
                    r.append(b, ' ', a)
                    );

                b
                .click(function(){

                    //# Trigger Event! onFileRemove
                    if(!MultiFile.trigger('onFileRemove', slave, MultiFile)) return false;
                    //# End Event!

                    MultiFile.n--;
                    MultiFile.current.disabled = false;

                    // Remove element, remove label, point to current
                    MultiFile.slaves[slave_count] = null;
                    $(slave).remove();
                    $(this).parent().remove();

                    // Show most current element again (move into view) and clear selection
                    $(MultiFile.current).css({
                        position:'',
                        top: ''
                    });
                    $(MultiFile.current).reset().val('').attr('value', '')[0].value = '';

                    //# Trigger Event! afterFileRemove
                    if(!MultiFile.trigger('afterFileRemove', slave, MultiFile)) return false;
                    //# End Event!

                    return false;
                });

                //# Trigger Event! afterFileAppend
                if(!MultiFile.trigger('afterFileAppend', slave, MultiFile)) return false;
            //# End Event!

            }; // MultiFile.addToList
            // Add element to selected files list



            // Bind functionality to the first element
            if(!MultiFile.MultiFile) MultiFile.addSlave(MultiFile.e, 0);

            // Increment control count
            //MultiFile.I++; // using window.MultiFile
            MultiFile.n++;

            // Save control to element
            MultiFile.E.data('MultiFile', MultiFile);


        //#####################################################################
        // MAIN PLUGIN FUNCTIONALITY - END
        //#####################################################################
        }); // each element
    };

    /*--------------------------------------------------------*/

    /*
		### Core functionality and API ###
	*/
    $.extend($.fn.MultiFile, {
        /**
   * This method removes all selected files
   *
   * Returns a jQuery collection of all affected elements.
   *
   * @name reset
   * @type jQuery
   * @cat Plugins/MultiFile
   * @author Diego A. (http://www.fyneworks.com/)
   *
   * @example $.fn.MultiFile.reset();
   */
        reset: function(){
            var settings = $(this).data('MultiFile');
            //if(settings) settings.wrapper.find('a.MultiFile-remove').click();
            if(settings) settings.list.find('a.MultiFile-remove').click();
            return $(this);
        },


        /**
   * This utility makes it easy to disable all 'empty' file elements in the document before submitting a form.
   * It marks the affected elements so they can be easily re-enabled after the form submission or validation.
   *
   * Returns a jQuery collection of all affected elements.
   *
   * @name disableEmpty
   * @type jQuery
   * @cat Plugins/MultiFile
   * @author Diego A. (http://www.fyneworks.com/)
   *
   * @example $.fn.MultiFile.disableEmpty();
   * @param String class (optional) A string specifying a class to be applied to all affected elements - Default: 'mfD'.
   */
        disableEmpty: function(klass){
            klass = (typeof(klass)=='string'?klass:'')||'mfD';
            var o = [];
            $('input:file.MultiFile').each(function(){
                if($(this).val()=='') o[o.length] = this;
            });
            return $(o).each(function(){
                this.disabled = true
            }).addClass(klass);
        },


        /**
			* This method re-enables 'empty' file elements that were disabled (and marked) with the $.fn.MultiFile.disableEmpty method.
			*
			* Returns a jQuery collection of all affected elements.
			*
			* @name reEnableEmpty
			* @type jQuery
			* @cat Plugins/MultiFile
			* @author Diego A. (http://www.fyneworks.com/)
			*
			* @example $.fn.MultiFile.reEnableEmpty();
			* @param String klass (optional) A string specifying the class that was used to mark affected elements - Default: 'mfD'.
			*/
        reEnableEmpty: function(klass){
            klass = (typeof(klass)=='string'?klass:'')||'mfD';
            return $('input:file.'+klass).removeClass(klass).each(function(){
                this.disabled = false
            });
        },


        /**
			* This method will intercept other jQuery plugins and disable empty file input elements prior to form submission
			*

			* @name intercept
			* @cat Plugins/MultiFile
			* @author Diego A. (http://www.fyneworks.com/)
			*
			* @example $.fn.MultiFile.intercept();
			* @param Array methods (optional) Array of method names to be intercepted
			*/
        intercepted: {},
        intercept: function(methods, context, args){
            var method, value;
            args = args || [];
            if(args.constructor.toString().indexOf("Array")<0) args = [ args ];
            if(typeof(methods)=='function'){
                $.fn.MultiFile.disableEmpty();
                value = methods.apply(context || window, args);
                //SEE-http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=27
                setTimeout(function(){
                    $.fn.MultiFile.reEnableEmpty()
                },1000);
                return value;
            };
            if(methods.constructor.toString().indexOf("Array")<0) methods = [methods];
            for(var i=0;i<methods.length;i++){
                method = methods[i]+''; // make sure that we have a STRING
                if(method) (function(method){ // make sure that method is ISOLATED for the interception
                    $.fn.MultiFile.intercepted[method] = $.fn[method] || function(){};
                    $.fn[method] = function(){
                        $.fn.MultiFile.disableEmpty();
                        value = $.fn.MultiFile.intercepted[method].apply(this, arguments);
                        //SEE-http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=27
                        setTimeout(function(){
                            $.fn.MultiFile.reEnableEmpty()
                        },1000);
                        return value;
                    }; // interception
                })(method); // MAKE SURE THAT method IS ISOLATED for the interception
            };// for each method
        } // $.fn.MultiFile.intercept

    });

    /*--------------------------------------------------------*/

    /*
		### Default Settings ###
		eg.: You can override default control like this:
		$.fn.MultiFile.options.accept = 'gif|jpg';
	*/
    $.fn.MultiFile.options = { //$.extend($.fn.MultiFile, { options: {
        accept: '', // accepted file extensions
        max: -1,    // maximum number of selectable files

        // name to use for newly created elements
        namePattern: '$name', // same name by default (which creates an array)

        // STRING: collection lets you show messages in different languages
        STRING: {
            remove:'x',
            denied:'You cannot select a $ext file.\nTry again...',
            file:'$file',
            selected:'File selected: $file',
            duplicate:'This file has already been selected:\n$file'
        },

        // name of methods that should be automcatically intercepted so the plugin can disable
        // extra file elements that are empty before execution and automatically re-enable them afterwards
        autoIntercept: [ 'submit', 'ajaxSubmit', 'ajaxForm', 'validate', 'valid' /* array of methods to intercept */ ],

        // error handling function
        error: function(s){
            /*
			ERROR! blockUI is not currently working in IE
			if($.blockUI){
				$.blockUI({
					message: s.replace(/\n/gi,'<br/>'),
					css: {
						border:'none', padding:'15px', size:'12.0pt',
						backgroundColor:'#900', color:'#fff',
						opacity:'.8','-webkit-border-radius': '10px','-moz-border-radius': '10px'
					}
				});
				window.setTimeout($.unblockUI, 2000);
			}
			else//{// save a byte!
			*/
            alert(s);
        //}// save a byte!
        }
    }; //} });

    /*--------------------------------------------------------*/

    /*
		### Additional Methods ###
		Required functionality outside the plugin's scope
	*/

    // Native input reset method - because this alone doesn't always work: $(element).val('').attr('value', '')[0].value = '';
    $.fn.reset = function(){
        return this.each(function(){
            try{
                this.reset();
            }catch(e){}
        });
};

/*--------------------------------------------------------*/

/*
		### Default implementation ###
		The plugin will attach itself to file inputs
		with the class 'multi' when the page loads
	*/
$(function(){
    //$("input:file.multi").MultiFile();
    $("input[type=file].multi").MultiFile();
});



/*# AVOID COLLISIONS #*/
})(jQuery);
/*# AVOID COLLISIONS #*/