'use strict';

var events = require('events');
var http = require('http');
var https = require('https');
var fs = require('fs');

function __extends(d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}

var Util = (function () {
    function Util() {
    }
    Util.getNameHash = function (path) {
        for (var r = 0, i = 0; i < path.length; i++) {
            r = (r << 5) - r + path.charCodeAt(i), r &= r;
        }
        return "bsync_" + Math.abs(r);
    };
    /**
     *  index >= 0, localFile is in files
     *  index < 0, localFile is not in files
     */
    Util.getFileIndex = function (files, localFile) {
        for (var i = 0; i < files.length; i++) {
            if (localFile == files[i].target) {
                return i;
            }
        }
        return -1;
    };
    Util.getFilesForCleanup = function (files, localFiles) {
        var filesForCleanup = [];
        for (var _i = 0, localFiles_1 = localFiles; _i < localFiles_1.length; _i++) {
            var localFile = localFiles_1[_i];
            var index = -1;
            index = Util.getFileIndex(files, localFile);
            if (index < 0) {
                filesForCleanup.push(localFile);
            }
            else {
                // splice for performance improvement only
                files.splice(index, 1);
            }
        }
        return filesForCleanup;
    };
    return Util;
}());

var NodeFileHandler = (function (_super) {
    __extends(NodeFileHandler, _super);
    function NodeFileHandler() {
        _super.apply(this, arguments);
    }
    NodeFileHandler.prototype.selectProtocol = function (url) {
        if (url.search(/^http:\/\//) === 0) {
            return http;
        }
        else if (url.search(/^https:\/\//) === 0) {
            return https;
        }
        else {
            return null;
        }
    };
    NodeFileHandler.prototype.download = function (source, target) {
        var _this = this;
        var handler = this.selectProtocol(source);
        if (!handler) {
            this.emit("error", "No handler for source: " + source);
            return this;
        }
        // file already exists and is not empty
        if (fs.existsSync(target) && (fs.statSync(target)['size'] > 0)) {
            this.emit("complete");
            return this;
        }
        else {
            var file_1 = fs.createWriteStream(target, { 'flags': 'a' });
            handler.get(source, function (response) {
                var size = response.headers['content-length']; // in bytes
                var prog = 0; // already downloaded
                var progCounts = 100; // how many progress events should be triggerd (1-100 %)
                var nextProg = (1 / progCounts);
                response.on('data', function (chunk) {
                    prog += chunk.length;
                    file_1.write(chunk, 'binary');
                    if ((prog / size) > nextProg) {
                        _this.emit('progress', prog / size);
                        nextProg += (1 / progCounts);
                    }
                });
                response.once('end', function () {
                    file_1.end();
                    _this.emit('complete');
                });
            }).on('error', function (error) {
                fs.unlink(target);
                _this.emit("error", "Error while downloading: " + error);
            });
            return this;
        }
    };
    NodeFileHandler.prototype.cleanup = function (files, basePath) {
        try {
            var localFiles = fs.readdirSync(basePath);
            Util.getFilesForCleanup(files, localFiles)
                .forEach(function (file) {
                fs.unlinkSync(basePath + "/" + file);
            });
        }
        catch (e) {
        }
        return this;
    };
    return NodeFileHandler;
}(events.EventEmitter));

var ElectronFileHandler = (function (_super) {
    __extends(ElectronFileHandler, _super);
    function ElectronFileHandler(ipcRenderer) {
        _super.call(this);
        this.ipcRenderer = ipcRenderer;
    }
    ElectronFileHandler.prototype.download = function (source, target) {
        var _this = this;
        this.ipcRenderer.once('bsync-download-complete', function () {
            _this.ipcRenderer.removeAllListeners('bsync-download-progress');
            _this.ipcRenderer.removeAllListeners('bsync-download-error');
            _this.emit('complete');
        });
        this.ipcRenderer.on('bsync-download-progress', function (progress) {
            _this.emit('progress', progress);
        });
        this.ipcRenderer.once('bsync-download-error', function (error) {
            _this.ipcRenderer.removeAllListeners('bsync-download-progress');
            _this.ipcRenderer.removeAllListeners('bsync-download-complete');
            _this.emit('error', error);
        });
        this.ipcRenderer.send('bsync-download', {
            source: source,
            target: target
        });
        return this;
    };
    ElectronFileHandler.prototype.cleanup = function (files) {
        var _this = this;
        return new Promise(function (resolve, reject) {
            _this.ipcRenderer.once('bsync-cleanup-complete', function () {
                _this.emit('cleanup-complete');
                resolve();
            });
            _this.ipcRenderer.send('bsync-cleanup', files);
        });
    };
    return ElectronFileHandler;
}(events.EventEmitter));

var CordovaFileHandler = (function (_super) {
    __extends(CordovaFileHandler, _super);
    function CordovaFileHandler() {
        _super.apply(this, arguments);
    }
    CordovaFileHandler.prototype.triggerFileTransfer = function (source, target) {
        var _this = this;
        var fileTransfer = new window['FileTransfer']();
        fileTransfer.onprogress = function (progress) {
            _this.emit('progress', progress.loaded / progress.total);
        };
        fileTransfer.download(source, target, function (entry) {
            _this.emit('complete', entry);
        }, function (error) {
            _this.emit('error', error);
        }, true);
    };
    CordovaFileHandler.prototype.download = function (source, target) {
        var _this = this;
        if (!window['FileTransfer']) {
            this.emit('error', 'Cordova FileTransfer object undefined');
        }
        window['resolveLocalFileSystemURL'](target, function (entry) {
            entry.getMetadata(function (metadata) {
                if (metadata.size > 0) {
                    _this.emit('complete', entry);
                }
                else {
                    // file empty trigger transfer
                    _this.triggerFileTransfer(source, target);
                }
            }, function () {
                // cannot read metadata trigger transfer
                _this.triggerFileTransfer(source, target);
            });
        }, function () {
            // file not found, so download it
            _this.triggerFileTransfer(source, target);
        });
        return this;
    };
    CordovaFileHandler.prototype.cleanup = function (files, basePath) {
        var _this = this;
        var filesForCleanup = [];
        return new Promise(function (resolve, reject) {
            if (window['resolveLocalFileSystemURL']) {
                window['resolveLocalFileSystemURL'](basePath, function (entry) {
                    var reader = entry.createReader();
                    reader.readEntries(function (entries) {
                        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
                            var e = entries_1[_i];
                            if (e && e.isFile) {
                                if (Util.getFileIndex(files, e.name) < 0) {
                                    filesForCleanup.push(e);
                                }
                            }
                        }
                        var index = 0;
                        var error = false;
                        var cleanupError = function (error) {
                            _this.emit('cleanup-error', error);
                            reject();
                            error = true;
                        };
                        var cleanupNext = function () {
                            if (index < filesForCleanup.length && !error) {
                                filesForCleanup[index].remove(cleanupNext, cleanupError);
                                index += 1;
                            }
                            else if (!error) {
                                _this.emit('cleanup-complete', filesForCleanup);
                                resolve();
                            }
                        };
                        cleanupNext();
                    }, function (error) { _this.emit('cleanup-error', error); reject(); });
                });
            }
        });
    };
    return CordovaFileHandler;
}(events.EventEmitter));

var FileReplicator = (function (_super) {
    __extends(FileReplicator, _super);
    function FileReplicator() {
        _super.call(this);
        this._files = [];
        this._itemValidator = null;
        this._fileHandler = null;
        this._retryTimeout = 100;
        this._retries = 10;
        this._itemKey = "type";
        this._itemValue = "asset";
        this._itemSourceAttribute = "source";
        this._itemTargetAttribute = "target";
        this._targetDirectory = "";
    }
    Object.defineProperty(FileReplicator.prototype, "files", {
        get: function () {
            return this._files;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FileReplicator.prototype, "fileHandler", {
        get: function () {
            return this._fileHandler;
        },
        set: function (handler) {
            this._fileHandler = handler;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FileReplicator.prototype, "retryTimeout", {
        set: function (timeout) {
            this._retryTimeout = timeout;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FileReplicator.prototype, "itemValidator", {
        set: function (validator) {
            this._itemValidator = validator;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FileReplicator.prototype, "itemKey", {
        get: function () {
            return this._itemKey;
        },
        set: function (key) {
            this._itemKey = key;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FileReplicator.prototype, "itemValue", {
        get: function () {
            return this._itemValue;
        },
        set: function (value) {
            this._itemValue = value;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FileReplicator.prototype, "itemSourceAttribute", {
        get: function () {
            return this._itemSourceAttribute;
        },
        set: function (sourceAttribute) {
            this._itemSourceAttribute = sourceAttribute;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FileReplicator.prototype, "itemTargetAttribute", {
        get: function () {
            return this._itemTargetAttribute;
        },
        set: function (targetAttribute) {
            this._itemTargetAttribute = targetAttribute;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FileReplicator.prototype, "targetDirectory", {
        get: function () {
            return this._targetDirectory;
        },
        set: function (targetDirectory) {
            this._targetDirectory = targetDirectory;
        },
        enumerable: true,
        configurable: true
    });
    FileReplicator.prototype.clear = function (files) {
        if (files === void 0) { files = []; }
        this._files = files;
    };
    /**
     * change from pouchdb replicate
     */
    FileReplicator.prototype.pushChanges = function (docs) {
        var items = [];
        if (docs && docs.length > 0) {
            for (var _i = 0, docs_1 = docs; _i < docs_1.length; _i++) {
                var item = docs_1[_i];
                if (item[this._itemKey] && item[this._itemKey] === this._itemValue) {
                    items.push(item);
                }
            }
        }
        var files = this.prepareFiles(items);
        for (var _a = 0, files_1 = files; _a < files_1.length; _a++) {
            var file = files_1[_a];
            this._files.push(file);
        }
    };
    FileReplicator.prototype.downloadFiles = function (files, fileHandler, index) {
        var _this = this;
        if (index === void 0) { index = 0; }
        if (index >= files.length) {
            return;
        }
        this.emit('start', { progress: 0, index: index, length: files.length });
        fileHandler
            .on('progress', function (progress) {
            _this.emit('file-progress', { progress: progress, index: index, length: files.length });
        })
            .once('error', function (error) {
            _this.emit('file-error', { progress: 0, index: index, length: files.length, error: error });
            fileHandler.removeAllListeners();
        })
            .once('complete', function () {
            _this.emit('file-complete', { progress: 100, index: index, length: files.length });
            fileHandler.removeAllListeners();
            _this.downloadFiles(files, fileHandler, index + 1);
        })
            .download(files[index].source, this.targetDirectory + files[index].target);
    };
    FileReplicator.prototype.prepareFiles = function (items) {
        var output = [];
        for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
            var item = items_1[_i];
            if (item[this._itemSourceAttribute] && (!this._itemValidator || this._itemValidator(item))) {
                var file = { source: item[this._itemSourceAttribute], target: '' };
                if (item[this._itemTargetAttribute]) {
                    file.target = item[this._itemTargetAttribute];
                }
                else {
                    file.target = Util.getNameHash(file.source);
                }
                output.push(file);
            }
        }
        return output;
    };
    FileReplicator.prototype.start = function (retries) {
        var _this = this;
        if (retries === void 0) { retries = 10; }
        this._retries = retries;
        this.on('file-complete', function (event) {
            if ((event.index + 1) >= event.length) {
                _this.replicationFinalized(event.index);
            }
        });
        this.on('file-error', function (event) {
            _this.replicationFinalized(event.index);
        });
        if (this._fileHandler && this._files.length > 0) {
            this.downloadFiles(this._files, this._fileHandler);
        }
        else {
            this.emit('complete');
        }
    };
    FileReplicator.prototype.cleanup = function () {
        var _this = this;
        this.fileHandler
            .cleanup(this._files, this._targetDirectory)
            .then(function () {
            _this.emit('cleanup-complete');
        }).catch(function () {
            _this.emit('cleanup-error');
        });
    };
    FileReplicator.prototype.replicationFinalized = function (lastIndex) {
        var _this = this;
        if (lastIndex + 1 >= this._files.length) {
            this.emit('complete');
        }
        else if (this._retries > 0) {
            this._files.splice(0, lastIndex);
            setTimeout(function () {
                _this._retries = -1;
                _this.downloadFiles(_this._files, _this._fileHandler);
            }, this._retryTimeout);
        }
        else {
            this.emit('error');
        }
    };
    return FileReplicator;
}(events.EventEmitter));

var CONFIG_ITEM_KEY = "itemKey";
var CONFIG_ITEM_VALUE = "itemValue";
var CONFIG_ITEM_SOURCE_ATTRIBUTE = "itemSourceAttribute";
var CONFIG_ITEM_TARGET_ATTRIBUTE = "itemTargetAttribute";

var CONFIG_RETRY_TIMEOUT = "retryTimeout";

var CONFIG_TARGET_DIRECTORY = "targetDirectory";
var Config = (function () {
    function Config() {
        this.config = {};
    }
    Config.prototype.hasConfig = function (key) {
        if (this.config[key]) {
            return true;
        }
        return false;
    };
    Config.prototype.getConfig = function (key) {
        return this.config[key];
    };
    Config.prototype.setConfig = function (key, value) {
        this.config[key] = value;
        return this;
    };
    return Config;
}());

var ENV_NODE = "node";
var ENV_ELECTRON = "electron";
var ENV_CORDOVA = "cordova";
var ENV_UNKNOWN = "unknown";
var ServiceLocator = (function () {
    function ServiceLocator() {
    }
    ServiceLocator.addFileHandler = function (environment, fileHandler) {
        ServiceLocator.fileHandlers[environment] = fileHandler;
    };
    ServiceLocator.getConfig = function () {
        if (!ServiceLocator.config) {
            ServiceLocator.config = new Config();
        }
        return ServiceLocator.config;
    };
    ServiceLocator.getEnvironment = function () {
        if (typeof window != 'undefined' && typeof window['require'] === 'function' && window['require']('electron')) {
            return ENV_ELECTRON;
        }
        if (typeof window != 'undefined' && typeof window['FileTransfer'] === 'function') {
            return ENV_CORDOVA;
        }
        if (typeof process != 'undefined' && typeof process === 'object') {
            return ENV_NODE;
        }
        return ENV_UNKNOWN;
    };
    ServiceLocator.getFileHandler = function () {
        var environment = ServiceLocator.getEnvironment();
        if (ServiceLocator.fileHandlers[environment]) {
            return ServiceLocator.fileHandlers[environment];
        }
        if (environment === ENV_ELECTRON) {
            return new ElectronFileHandler(window['require']('electron').ipcRenderer);
        }
        if (environment === ENV_CORDOVA) {
            return new CordovaFileHandler();
        }
        if (environment === ENV_NODE) {
            return new NodeFileHandler();
        }
        return null;
    };
    ServiceLocator.getFileReplicator = function () {
        if (!ServiceLocator.fileReplicator) {
            ServiceLocator.fileReplicator = new FileReplicator();
            ServiceLocator.fileReplicator.fileHandler = ServiceLocator.getFileHandler();
        }
        if (ServiceLocator.getConfig().hasConfig(CONFIG_RETRY_TIMEOUT)) {
            ServiceLocator.fileReplicator.retryTimeout = ServiceLocator.getConfig().getConfig(CONFIG_RETRY_TIMEOUT);
        }
        if (ServiceLocator.getConfig().hasConfig(CONFIG_ITEM_KEY)) {
            ServiceLocator.fileReplicator.itemKey = ServiceLocator.getConfig().getConfig(CONFIG_ITEM_KEY);
        }
        if (ServiceLocator.getConfig().hasConfig(CONFIG_ITEM_VALUE)) {
            ServiceLocator.fileReplicator.itemValue = ServiceLocator.getConfig().getConfig(CONFIG_ITEM_VALUE);
        }
        if (ServiceLocator.getConfig().hasConfig(CONFIG_ITEM_SOURCE_ATTRIBUTE)) {
            ServiceLocator.fileReplicator.itemSourceAttribute = ServiceLocator.getConfig().getConfig(CONFIG_ITEM_SOURCE_ATTRIBUTE);
        }
        if (ServiceLocator.getConfig().hasConfig(CONFIG_ITEM_TARGET_ATTRIBUTE)) {
            ServiceLocator.fileReplicator.itemTargetAttribute = ServiceLocator.getConfig().getConfig(CONFIG_ITEM_TARGET_ATTRIBUTE);
        }
        if (ServiceLocator.getConfig().hasConfig(CONFIG_TARGET_DIRECTORY)) {
            ServiceLocator.fileReplicator.targetDirectory = ServiceLocator.getConfig().getConfig(CONFIG_TARGET_DIRECTORY);
        }
        return ServiceLocator.fileReplicator;
    };
    ServiceLocator.fileHandlers = {};
    return ServiceLocator;
}());

var Bsync = (function () {
    function Bsync() {
    }
    Bsync.configIpcMain = function (ipcMain, basePath) {
        ipcMain.on('bsync-download', function (event, args) {
            var nodeFileHander = new NodeFileHandler();
            nodeFileHander
                .on('progress', function (progress) { event.sender.send('bsync-download-progress', progress); })
                .once('error', function (error) { nodeFileHander.removeAllListeners(); event.sender.send('bsync-download-error', error); })
                .once('complete', function () { nodeFileHander.removeAllListeners(); event.sender.send('bsync-download-complete'); })
                .download(args.source, basePath + "/" + args.target);
        });
        ipcMain.on('bsync-cleanup', function (event, args) {
            var nodeFileHandler = new NodeFileHandler();
            nodeFileHandler.cleanup(args.files, basePath);
            event.sender.send('bsync-cleanup-complete');
        });
    };
    Bsync.NodeFileHandler = NodeFileHandler;
    Bsync.ServiceLocator = ServiceLocator;
    return Bsync;
}());

module.exports = Bsync;
//# sourceMappingURL=node-build.js.map