/*
 Speed Plug-in

 Features:
 *Adds several properties to the 'file' object indicated upload speed, time left, upload time, etc.
 - currentSpeed -- String indicating the upload speed, bits per second
 - averageSpeed -- Overall average upload speed, bits per second
 - movingAverageSpeed -- Speed over averaged over the last several measurements, bits per second
 - timeRemaining -- Estimated remaining upload time in seconds
 - timeElapsed -- Number of seconds passed for this upload
 - percentUploaded -- Percentage of the file uploaded (0 to 100)
 - sizeUploaded -- Formatted size uploaded so far, bytes

 *Adds setting 'moving_average_history_size' for defining the window size used to calculate the moving average speed.

 *Adds several Formatting functions for formatting that values provided on the file object.
 - SWFUpload.speed.formatBPS(bps) -- outputs string formatted in the best units (Gbps, Mbps, Kbps, bps)
 - SWFUpload.speed.formatTime(seconds) -- outputs string formatted in the best units (x Hr y M z S)
 - SWFUpload.speed.formatSize(bytes) -- outputs string formatted in the best units (w GB x MB y KB z B )
 - SWFUpload.speed.formatPercent(percent) -- outputs string formatted with a percent sign (x.xx %)
 - SWFUpload.speed.formatUnits(baseNumber, divisionArray, unitLabelArray, fractionalBoolean)
 - Formats a number using the division array to determine how to apply the labels in the Label Array
 - factionalBoolean indicates whether the number should be returned as a single fractional number with a unit (speed)
 or as several numbers labeled with units (time)
 */

var SWFUpload;
if (typeof(SWFUpload) === "function") {
    SWFUpload.speed = {};

    SWFUpload.prototype.initSettings = (function (oldInitSettings) {
        return function (userSettings) {
            if (typeof(oldInitSettings) === "function") {
                oldInitSettings.call(this, userSettings);
            }

            this.ensureDefault = function (settingName, defaultValue) {
                this.settings[settingName] = (userSettings[settingName] == undefined) ? defaultValue : userSettings[settingName];
            };

            // List used to keep the speed stats for the files we are tracking
            this.fileSpeedStats = {};
            this.speedSettings = {};

            this.ensureDefault("moving_average_history_size", "10");

            this.speedSettings.user_file_queued_handler = this.settings.file_queued_handler;
            this.speedSettings.user_file_queue_error_handler = this.settings.file_queue_error_handler;
            this.speedSettings.user_upload_start_handler = this.settings.upload_start_handler;
            this.speedSettings.user_upload_error_handler = this.settings.upload_error_handler;
            this.speedSettings.user_upload_progress_handler = this.settings.upload_progress_handler;
            this.speedSettings.user_upload_success_handler = this.settings.upload_success_handler;
            this.speedSettings.user_upload_complete_handler = this.settings.upload_complete_handler;

            this.settings.file_queued_handler = SWFUpload.speed.fileQueuedHandler;
            this.settings.file_queue_error_handler = SWFUpload.speed.fileQueueErrorHandler;
            this.settings.upload_start_handler = SWFUpload.speed.uploadStartHandler;
            this.settings.upload_error_handler = SWFUpload.speed.uploadErrorHandler;
            this.settings.upload_progress_handler = SWFUpload.speed.uploadProgressHandler;
            this.settings.upload_success_handler = SWFUpload.speed.uploadSuccessHandler;
            this.settings.upload_complete_handler = SWFUpload.speed.uploadCompleteHandler;

            delete this.ensureDefault;
        };
    })(SWFUpload.prototype.initSettings);


    SWFUpload.speed.fileQueuedHandler = function (file) {
        if (typeof this.speedSettings.user_file_queued_handler === "function") {
            file = SWFUpload.speed.extendFile(file);

            return this.speedSettings.user_file_queued_handler.call(this, file);
        }
    };

    SWFUpload.speed.fileQueueErrorHandler = function (file, errorCode, message) {
        if (typeof this.speedSettings.user_file_queue_error_handler === "function") {
            file = SWFUpload.speed.extendFile(file);

            return this.speedSettings.user_file_queue_error_handler.call(this, file, errorCode, message);
        }
    };

    SWFUpload.speed.uploadStartHandler = function (file) {
        if (typeof this.speedSettings.user_upload_start_handler === "function") {
            file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
            return this.speedSettings.user_upload_start_handler.call(this, file);
        }
    };

    SWFUpload.speed.uploadErrorHandler = function (file, errorCode, message) {
        file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
        SWFUpload.speed.removeTracking(file, this.fileSpeedStats);

        if (typeof this.speedSettings.user_upload_error_handler === "function") {
            return this.speedSettings.user_upload_error_handler.call(this, file, errorCode, message);
        }
    };
    SWFUpload.speed.uploadProgressHandler = function (file, bytesComplete, bytesTotal) {
        this.updateTracking(file, bytesComplete);
        file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);

        if (typeof this.speedSettings.user_upload_progress_handler === "function") {
            return this.speedSettings.user_upload_progress_handler.call(this, file, bytesComplete, bytesTotal);
        }
    };

    SWFUpload.speed.uploadSuccessHandler = function (file, serverData) {
        if (typeof this.speedSettings.user_upload_success_handler === "function") {
            file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
            return this.speedSettings.user_upload_success_handler.call(this, file, serverData);
        }
    };
    SWFUpload.speed.uploadCompleteHandler = function (file) {
        file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
        SWFUpload.speed.removeTracking(file, this.fileSpeedStats);

        if (typeof this.speedSettings.user_upload_complete_handler === "function") {
            return this.speedSettings.user_upload_complete_handler.call(this, file);
        }
    };

    // Private: extends the file object with the speed plugin values
    SWFUpload.speed.extendFile = function (file, trackingList) {
        var tracking;

        if (!file) {
            return file;
        }

        if (trackingList) {
            tracking = trackingList[file.id];
        }

        if (tracking) {
            file.currentSpeed = tracking.currentSpeed;
            file.averageSpeed = tracking.averageSpeed;
            file.movingAverageSpeed = tracking.movingAverageSpeed;
            file.timeRemaining = tracking.timeRemaining;
            file.timeElapsed = tracking.timeElapsed;
            file.percentUploaded = tracking.percentUploaded;
            file.sizeUploaded = tracking.bytesUploaded;

        } else {
            file.currentSpeed = 0;
            file.averageSpeed = 0;
            file.movingAverageSpeed = 0;
            file.timeRemaining = 0;
            file.timeElapsed = 0;
            file.percentUploaded = 0;
            file.sizeUploaded = 0;
        }

        return file;
    };

    // Private: Updates the speed tracking object, or creates it if necessary
    SWFUpload.prototype.updateTracking = function (file, bytesUploaded) {
        var tracking = this.fileSpeedStats[file.id];
        if (!tracking) {
            this.fileSpeedStats[file.id] = tracking = {};
        }

        // Sanity check inputs
        bytesUploaded = bytesUploaded || tracking.bytesUploaded || 0;
        if (bytesUploaded < 0) {
            bytesUploaded = 0;
        }
        if (bytesUploaded > file.size) {
            bytesUploaded = file.size;
        }

        var tickTime = (new Date()).getTime();
        if (!tracking.startTime) {
            tracking.startTime = (new Date()).getTime();
            tracking.lastTime = tracking.startTime;
            tracking.currentSpeed = 0;
            tracking.averageSpeed = 0;
            tracking.movingAverageSpeed = 0;
            tracking.movingAverageHistory = [];
            tracking.timeRemaining = 0;
            tracking.timeElapsed = 0;
            tracking.percentUploaded = bytesUploaded / file.size;
            tracking.bytesUploaded = bytesUploaded;
        } else if (tracking.startTime > tickTime) {
            this.debug("When backwards in time");
        } else {
            // Get time and deltas
            var now = (new Date()).getTime();
            var lastTime = tracking.lastTime;
            var deltaTime = now - lastTime;
            var deltaBytes = bytesUploaded - tracking.bytesUploaded;

            if (deltaBytes === 0 || deltaTime === 0) {
                return tracking;
            }

            // Update tracking object
            tracking.lastTime = now;
            tracking.bytesUploaded = bytesUploaded;

            // Calculate speeds
            tracking.currentSpeed = (deltaBytes * 8 ) / (deltaTime / 1000);
            tracking.averageSpeed = (tracking.bytesUploaded * 8) / ((now - tracking.startTime) / 1000);

            // Calculate moving average
            tracking.movingAverageHistory.push(tracking.currentSpeed);
            if (tracking.movingAverageHistory.length > this.settings.moving_average_history_size) {
                tracking.movingAverageHistory.shift();
            }

            tracking.movingAverageSpeed = SWFUpload.speed.calculateMovingAverage(tracking.movingAverageHistory);

            // Update times
            tracking.timeRemaining = (file.size - tracking.bytesUploaded) * 8 / tracking.movingAverageSpeed;
            tracking.timeElapsed = (now - tracking.startTime) / 1000;

            // Update percent
            tracking.percentUploaded = (tracking.bytesUploaded / file.size * 100);
        }

        return tracking;
    };
    SWFUpload.speed.removeTracking = function (file, trackingList) {
        try {
            trackingList[file.id] = null;
            delete trackingList[file.id];
        } catch (ex) {
        }
    };

    SWFUpload.speed.formatUnits = function (baseNumber, unitDivisors, unitLabels, singleFractional) {
        var i, unit, unitDivisor, unitLabel;

        if (baseNumber === 0) {
            return "0 " + unitLabels[unitLabels.length - 1];
        }

        if (singleFractional) {
            unit = baseNumber;
            unitLabel = unitLabels.length >= unitDivisors.length ? unitLabels[unitDivisors.length - 1] : "";
            for (i = 0; i < unitDivisors.length; i++) {
                if (baseNumber >= unitDivisors[i]) {
                    unit = (baseNumber / unitDivisors[i]).toFixed(2);
                    unitLabel = unitLabels.length >= i ? " " + unitLabels[i] : "";
                    break;
                }
            }

            return unit + unitLabel;
        } else {
            var formattedStrings = [];
            var remainder = baseNumber;

            for (i = 0; i < unitDivisors.length; i++) {
                unitDivisor = unitDivisors[i];
                unitLabel = unitLabels.length > i ? " " + unitLabels[i] : "";

                unit = remainder / unitDivisor;
                if (i < unitDivisors.length - 1) {
                    unit = Math.floor(unit);
                } else {
                    unit = unit.toFixed(2);
                }
                if (unit > 0) {
                    remainder = remainder % unitDivisor;

                    formattedStrings.push(unit + unitLabel);
                }
            }

            return formattedStrings.join(" ");
        }
    };

    SWFUpload.speed.formatBPS = function (baseNumber) {
        var bpsUnits = [1073741824, 1048576, 1024, 1], bpsUnitLabels = ["Gbps", "Mbps", "Kbps", "bps"];
        return SWFUpload.speed.formatUnits(baseNumber, bpsUnits, bpsUnitLabels, true);

    };
    SWFUpload.speed.formatTime = function (baseNumber) {
        var timeUnits = [86400, 3600, 60, 1], timeUnitLabels = ["d", "h", "m", "s"];
        return SWFUpload.speed.formatUnits(baseNumber, timeUnits, timeUnitLabels, false);

    };
    SWFUpload.speed.formatBytes = function (baseNumber) {
        var sizeUnits = [1073741824, 1048576, 1024, 1], sizeUnitLabels = ["GB", "MB", "KB", "bytes"];
        return SWFUpload.speed.formatUnits(baseNumber, sizeUnits, sizeUnitLabels, true);

    };
    SWFUpload.speed.formatPercent = function (baseNumber) {
        return baseNumber.toFixed(2) + " %";
    };

    SWFUpload.speed.calculateMovingAverage = function (history) {
        var vals = [], size, sum = 0.0, mean = 0.0, varianceTemp = 0.0, variance = 0.0, standardDev = 0.0;
        var i;
        var mSum = 0, mCount = 0;

        size = history.length;

        // Check for sufficient data
        if (size >= 8) {
            // Clone the array and Calculate sum of the values
            for (i = 0; i < size; i++) {
                vals[i] = history[i];
                sum += vals[i];
            }

            mean = sum / size;

            // Calculate variance for the set
            for (i = 0; i < size; i++) {
                varianceTemp += Math.pow((vals[i] - mean), 2);
            }

            variance = varianceTemp / size;
            standardDev = Math.sqrt(variance);

            //Standardize the Data
            for (i = 0; i < size; i++) {
                vals[i] = (vals[i] - mean) / standardDev;
            }

            // Calculate the average excluding outliers
            var deviationRange = 2.0;
            for (i = 0; i < size; i++) {

                if (vals[i] <= deviationRange && vals[i] >= -deviationRange) {
                    mCount++;
                    mSum += history[i];
                }
            }

        } else {
            // Calculate the average (not enough data points to remove outliers)
            mCount = size;
            for (i = 0; i < size; i++) {
                mSum += history[i];
            }
        }

        return mSum / mCount;
    };

}