'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 Bsync = (function () {
    function Bsync() {
    }
    Bsync.configIpcMain = function (ipcMain, basePath) {
        ipcMain.on('bsync-download', function (event, args) {
            var nodeFileHander = new NodeFileHandler();
            nodeFileHander.download(args.source, basePath + "/" + args.target)
                .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'); });
        });
        ipcMain.on('bsync-cleanup', function (event, args) {
            var nodeFileHandler = new NodeFileHandler();
            nodeFileHandler.cleanup(args.files, basePath);
            event.sender.send('bsync-cleanup-complete');
        });
    };
    return Bsync;
}());

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