define([
    "jquery",
    "underscore",
    "utils",
    "storage",
    "eventMgr",
    "fileSystem",
    "fileMgr",
    "classes/Provider",
    "providers/dropboxProvider",
    "providers/gdriveProvider",
    "providers/gdrivesecProvider",
    "providers/gdriveterProvider"
], function($, _, utils, storage, eventMgr, fileSystem, fileMgr, Provider) {

    var synchronizer = {};

    // Create a map with providerId: providerModule
    var providerMap = _.chain(arguments).map(function(argument) {
        return argument instanceof Provider && [
            argument.providerId,
            argument
        ];
    }).compact().object().value();

    // Retrieve sync locations from storage
    (function() {
        var syncIndexMap = {};
        _.each(fileSystem, function(fileDesc) {
            utils.retrieveIndexArray(fileDesc.fileIndex + ".sync").forEach(function(syncIndex) {
                try {
                    var syncAttributes = JSON.parse(storage[syncIndex]);
                    // Store syncIndex
                    syncAttributes.syncIndex = syncIndex;
                    // Replace provider ID by provider module in attributes
                    var provider = providerMap[syncAttributes.provider];
                    if(!provider) {
                        throw new Error("Invalid provider ID: " + syncAttributes.provider);
                    }
                    syncAttributes.provider = provider;
                    fileDesc.syncLocations[syncIndex] = syncAttributes;
                    syncIndexMap[syncIndex] = syncAttributes;
                }
                catch(e) {
                    // storage can be corrupted
                    eventMgr.onError(e);
                    // Remove sync location
                    utils.removeIndexFromArray(fileDesc.fileIndex + ".sync", syncIndex);
                }
            });
        });

        // Clean fields from deleted files in local storage
        Object.keys(storage).forEach(function(key) {
            var match = key.match(/sync\.\S+/);
            if(match && !syncIndexMap.hasOwnProperty(match[0])) {
                storage.removeItem(key);
            }
        });
    })();

    // AutoSync configuration
    _.each(providerMap, function(provider) {
        provider.autosyncConfig = utils.retrieveIgnoreError(provider.providerId + ".autosyncConfig") || {};
    });

    // Returns true if at least one file has synchronized location
    synchronizer.hasSync = function(provider) {
        return _.some(fileSystem, function(fileDesc) {
            return _.some(fileDesc.syncLocations, function(syncAttributes) {
                return provider === undefined || syncAttributes.provider === provider;
            });
        });
    };

    /***************************************************************************
     * Standard synchronization
     **************************************************************************/

    // Recursive function to upload a single file on multiple locations
    var uploadSyncAttributesList = [];
    var uploadContent;
    var uploadContentCRC;
    var uploadTitle;
    var uploadTitleCRC;
    var uploadDiscussionList;
    var uploadDiscussionListCRC;
    function locationUp(callback) {

        // No more synchronized location for this document
        if(uploadSyncAttributesList.length === 0) {
            return fileUp(callback);
        }

        // Dequeue a synchronized location
        var syncAttributes = uploadSyncAttributesList.pop();

        var providerSyncUpFunction = syncAttributes.provider.syncUp;
        // Call a special function in case of a real time synchronized location
        if(syncAttributes.isRealtime === true) {
            providerSyncUpFunction = syncAttributes.provider.syncUpRealtime;
        }

        // Use the specified provider to perform the upload
        providerSyncUpFunction(
            uploadContent,
            uploadContentCRC,
            uploadTitle,
            uploadTitleCRC,
            uploadDiscussionList,
            uploadDiscussionListCRC,
            syncAttributes,
            function(error, uploadFlag) {
                if(uploadFlag === true) {
                    // If uploadFlag is true, request another upload cycle
                    uploadCycle = true;
                }
                if(error) {
                    return callback(error);
                }
                if(uploadFlag) {
                    // Update syncAttributes in storage
                    utils.storeAttributes(syncAttributes);
                }
                locationUp(callback);
            }
        );
    }

    // Recursive function to upload multiple files
    var uploadFileList = [];
    function fileUp(callback) {

        // No more fileDesc to synchronize
        if(uploadFileList.length === 0) {
            return syncUp(callback);
        }

        // Dequeue a fileDesc to synchronize
        var fileDesc = uploadFileList.pop();
        uploadSyncAttributesList = _.values(fileDesc.syncLocations);
        if(uploadSyncAttributesList.length === 0) {
            return fileUp(callback);
        }

        // Get document title/content
        uploadContent = fileDesc.content;
        uploadContentCRC = utils.crc32(uploadContent);
        uploadTitle = fileDesc.title;
        uploadTitleCRC = utils.crc32(uploadTitle);
        uploadDiscussionList = fileDesc.discussionListJSON;
        uploadDiscussionListCRC = utils.crc32(uploadDiscussionList);
        locationUp(callback);
    }

    // Entry point for up synchronization (upload changes)
    var uploadCycle = false;
    function syncUp(callback) {
        if(uploadCycle === true) {
            // New upload cycle
            uploadCycle = false;
            uploadFileList = _.values(fileSystem);
            fileUp(callback);
        }
        else {
            callback();
        }
    }

    // Recursive function to download changes from multiple providers
    var providerList = [];
    function providerDown(callback) {
        if(providerList.length === 0) {
            return callback();
        }
        var provider = providerList.pop();

        // Check that provider has files to sync
        if(!synchronizer.hasSync(provider)) {
            return providerDown(callback);
        }

        // Perform provider's syncDown
        provider.syncDown(function(error) {
            if(error) {
                return callback(error);
            }
            providerDown(callback);
        });
    }

    // Entry point for down synchronization (download changes)
    function syncDown(callback) {
        providerList = _.values(providerMap);
        providerDown(callback);
    }

    // Listen to offline status changes
    var isOffline = false;
    eventMgr.addListener("onOfflineChanged", function(isOfflineParam) {
        isOffline = isOfflineParam;
    });

    // Main entry point for synchronization
    var syncRunning = false;
    synchronizer.sync = function() {
        // If sync is already running or offline
        if(syncRunning === true || isOffline === true) {
            return false;
        }
        syncRunning = true;
        eventMgr.onSyncRunning(true);
        uploadCycle = true;

        function isError(error) {
            if(error !== undefined) {
                syncRunning = false;
                eventMgr.onSyncRunning(false);
                return true;
            }
            return false;
        }

        syncDown(function(error) {
            if(isError(error)) {
                return;
            }
            syncUp(function(error) {
                if(isError(error)) {
                    return;
                }
                syncRunning = false;
                eventMgr.onSyncRunning(false);
                eventMgr.onSyncSuccess();
            });
        });
        return true;
    };

    /***************************************************************************
     * Realtime synchronization
     **************************************************************************/

    var isOnline = true;

    // Tries to start/stop real time sync on online/offline event
    function onOfflineChanged(isOfflineParam) {
        if(isOfflineParam === false) {
            isOnline = true;
            startRealtimeSync();
        }
        else {
            stopRealtimeSync();
            isOnline = false;
        }
    }

    // Starts real time synchronization if:
    // 1. current file has real time sync location
    // 2. we are online
    function startRealtimeSync() {
        var fileDesc = fileMgr.currentFile;
        _.each(fileDesc.syncLocations, function(syncAttributes) {
            syncAttributes.isRealtime && syncAttributes.provider.startRealtimeSync(fileDesc, syncAttributes);
        });
    }

    // Stops previously started synchronization if any
    function stopRealtimeSync() {
        _.each(providerMap, function(provider) {
            provider.stopRealtimeSync && provider.stopRealtimeSync();
        });
    }

    // Triggers realtime synchronization from eventMgr events
    if(window.viewerMode === false) {
        // On file open, try to start realtime sync
        eventMgr.addListener("onFileOpen", startRealtimeSync);
        // On new sync location, try to start realtime sync
        eventMgr.addListener("onSyncExportSuccess", startRealtimeSync);
        // On file close, stop any active realtime synchronization
        eventMgr.addListener("onFileClosed", stopRealtimeSync);
        // Start/stop realtime sync depending on network status
        eventMgr.addListener("onOfflineChanged", onOfflineChanged);
        // Try to start realtime sync every 15 sec in case of error
        eventMgr.addListener("onPeriodicRun", _.throttle(startRealtimeSync, 15000));
        // Stop realtime sync if synchronized location is removed
        eventMgr.addListener("onSyncRemoved", function(fileDesc, syncAttributes) {
            fileDesc === fileMgr.currentFile && syncAttributes.isRealtime && syncAttributes.provider.stopRealtimeSync();
        });
    }

    /***************************************************************************
     * Initialize module
     **************************************************************************/

    // Initialize the export dialog
    function initExportDialog(provider) {

        // Reset fields
        utils.resetModalInputs();

        // Load preferences
        var exportPreferences = utils.retrieveIgnoreError(provider.providerId + ".exportPreferences");
        if(exportPreferences) {
            _.each(provider.exportPreferencesInputIds, function(inputId) {
                var exportPreferenceValue = exportPreferences[inputId];
                if(_.isBoolean(exportPreferenceValue)) {
                    utils.setInputChecked("#input-sync-export-" + inputId, exportPreferenceValue);
                }
                else {
                    utils.setInputValue("#input-sync-export-" + inputId, exportPreferenceValue);
                }
            });
        }

        // Open dialog
        $(".modal-upload-" + provider.providerId).modal();
    }

    eventMgr.addListener("onFileCreated", function(fileDesc) {
        if(_.size(fileDesc.syncLocations) === 0) {
            _.each(providerMap, function(provider) {
                provider.autosyncConfig.enabled && provider.autosyncFile(fileDesc.title, fileDesc.content, fileDesc.discussionListJSON, provider.autosyncConfig, function(error, syncAttributes) {
                    if(error) {
                        return;
                    }
                    fileDesc.addSyncLocation(syncAttributes);
                    eventMgr.onSyncExportSuccess(fileDesc, syncAttributes);
                });
            });
        }
    });

    eventMgr.addListener("onReady", function() {
        // Init each provider
        _.each(providerMap, function(provider) {
            // Provider's import button
            $(".action-sync-import-" + provider.providerId).click(function(event) {
                provider.importFiles(event);
            });
            // Provider's export action
            $(".action-sync-export-dialog-" + provider.providerId).click(function() {
                initExportDialog(provider);
            });
            // Provider's autosync action
            $(".action-autosync-dialog-" + provider.providerId).click(function() {
                // Reset fields
                utils.resetModalInputs();
                // Load config
                provider.setAutosyncDialogConfig(provider);
                // Open dialog
                $(".modal-autosync-" + provider.providerId).modal();
            });
            $(".action-sync-export-" + provider.providerId).click(function(event) {
                var isRealtime = utils.getInputChecked("#input-sync-export-" + provider.providerId + "-realtime");
                var fileDesc = fileMgr.currentFile;

                if(isRealtime) {
                    if(_.size(fileDesc.syncLocations) > 0) {
                        return eventMgr.onError("Real time collaborative document can't be synchronized with multiple locations");
                    }
                    // Perform the provider's real time export
                    provider.exportRealtimeFile(event, fileDesc.title, fileDesc.content, fileDesc.discussionListJSON, function(error, syncAttributes) {
                        if(error) {
                            return;
                        }
                        syncAttributes.isRealtime = true;
                        fileDesc.addSyncLocation(syncAttributes);
                        eventMgr.onSyncExportSuccess(fileDesc, syncAttributes);
                    });
                }
                else {
                    if(_.size(fileDesc.syncLocations) > 0 && _.first(_.values(fileDesc.syncLocations)).isRealtime) {
                        eventMgr.onError("Real time collaborative document can't be synchronized with multiple locations");
                        return;
                    }
                    // Perform the provider's standard export
                    provider.exportFile(event, fileDesc.title, fileDesc.content, fileDesc.discussionListJSON, function(error, syncAttributes) {
                        if(error) {
                            return;
                        }
                        fileDesc.addSyncLocation(syncAttributes);
                        eventMgr.onSyncExportSuccess(fileDesc, syncAttributes);
                    });
                }

                // Store input values as preferences for next time we open the
                // export dialog
                var exportPreferences = {};
                _.each(provider.exportPreferencesInputIds, function(inputId) {
                    var inputElt = document.getElementById("input-sync-export-" + inputId);
                    if(inputElt.type == 'checkbox') {
                        exportPreferences[inputId] = inputElt.checked;
                    }
                    else {
                        exportPreferences[inputId] = inputElt.value;
                    }
                });
                storage[provider.providerId + ".exportPreferences"] = JSON.stringify(exportPreferences);
            });
            $(".action-autosync-" + provider.providerId).click(function(event) {
                var config = provider.getAutosyncDialogConfig(event);
                if(config !== undefined) {
                    storage[provider.providerId + ".autosyncConfig"] = JSON.stringify(config);
                    provider.autosyncConfig = config;
                }
            });
        });
    });

    eventMgr.onSynchronizerCreated(synchronizer);
    return synchronizer;
});