const FTP = require("ftp");
const _ = require('lodash');
const async = require("async");
const glob = require('glob');
const logging = 'debug';
const fs = require("fs");
const MAX_CONNECTIONS = 10;
const loggingLevels = ['none', 'basic', 'debug'];
const log = function (msg, lvl) {
    if (loggingLevels.indexOf(lvl) <= loggingLevels.indexOf(logging)) {
        console.log(msg);
    }
};

class FTPClient {
    constructor(config, option) {
        this.config = _.defaults(config || {}, {
            host: '172.16.37.28',
            port: 21,
            user: 'zx',
            password: 'ZX@spider_1620'
        });
        this.option = _.defaults(option || {}, {
            overwrite: 'older' // | 'all' | 'none'
        });
        this.ftp = new FTP();
        this.ftp.on('error', function (err) {
            throw new Error(err);
        });
    }

    connect(callback) {
        this.ftp.on('ready', () => {
            log('Connected to ' + this.config.host, 'debug');
            if (typeof callback !== 'undefined') {
                callback();
            }
        });

        this.ftp.connect(this.config || {});
    }

    upload(patterns, dest, options, uploadCallback) {
        options = _.defaults(options || {}, this.option);
        let paths, files, dirs, toDelete = [], ftp = this.ftp;
        paths = this._glob(patterns);
        paths = this._clean(paths, options.baseDir);
        paths = this._stat(paths);
        files = paths[1];
        dirs = paths[0];

        const deleteFiles = function (cb) {
            async.eachLimit(toDelete, MAX_CONNECTIONS, function (file, callback) {
                let destPath = (file.src.indexOf(options.baseDir) === 0 ?
                    file.src.substring(options.baseDir.length + 1) : file.src);

                log('Deleting ' + destPath, 'debug');

                if (file.isDirectory()) {
                    ftp.rmdir(destPath, function (err) {
                        if (err) {
                            log(err, 'debug');
                        }
                        callback();
                    });
                } else {
                    ftp.delete(destPath, function (err) {
                        if (err) {
                            log(err, 'debug');
                        }
                        callback();
                    });
                }
            }, cb);
        };

        const uploadFiles = function (cb) {
            async.eachLimit(files, MAX_CONNECTIONS, (file, callback) => {
                let destFileName = (file.src.indexOf(options.baseDir) === 0 ?
                    file.src.substring(options.baseDir.length + 1) : file.src);
                log('Uploading file ' + destFileName, 'debug');
                ftp.put(file.src, dest + '/' + destFileName, (err) => {
                    if (err) {
                        log('Error uploading file ' + destFileName + ': ' + err, 'basic');
                        file.uploaded = false;
                        file.error = err;
                    } else {
                        log('Finished uploading file ' + destFileName, 'basic');
                        file.uploaded = true;
                    }
                    callback();
                });
            }, cb);
        };

        const uploadDirs = function (cb) {
            async.eachLimit(dirs, MAX_CONNECTIONS, (dir, callback) => {
                let destPath = (dir.src.indexOf(options.baseDir) === 0 ?
                    dir.src.substring(options.baseDir.length + 1) : dir.src);

                log('Uploading directory ' + destPath, 'debug');

                ftp.mkdir(destPath, (err) => {
                    if (err) {
                        log('Error uploading directory ' + destPath + ': ' + err, 'basic');
                        dir.uploaded = false;
                        dir.error = err;
                    } else {
                        log('Finished uploading directory ' + destPath, 'basic');
                        dir.uploaded = true;
                    }
                    callback();
                })
            }, cb);
        };

        this._cwd(dest, function () {
            log('Moved to directory ' + dest, 'debug');
            let tasks = [];

            tasks.push(function (callback) {
                log('Delete files', 'debug');
                return deleteFiles(function (err) {
                    if (err) {
                        log(err, 'debug');
                    }
                    callback();
                });
            });

            tasks.push(function (callback) {
                log('Upload files', 'debug');
                return uploadFiles(function (err) {
                    if (err) {
                        log(err, 'debug');
                    }
                    else log('Uploaded files', 'debug');
                    callback();
                });
            });

            async.series(tasks, function (err) {
                if (err) throw err;
                ftp.end();
                log('Upload done', 'debug');
                let result = {
                    uploadedFiles: [],
                    uploadedDirs: [],
                    errors: {}
                };
                dirs.forEach(function (dir) {
                    if (dir.uploaded) {
                        result.uploadedDirs.push(dir.src);
                    } else {
                        result.errors[dir.src] = dir.error;
                    }
                });
                files.forEach(function (file) {
                    if (file.uploaded) {
                        result.uploadedFiles.push(file.src);
                    } else {
                        result.errors[file.src] = file.error;
                    }
                });
                log('Finished uploading ' + result.uploadedFiles.length + ' of ' + files.length + ' files.', 'basic');
                uploadCallback(result);
            });

        })
    }

    _clean(files, baseDir) {
        if (!baseDir) {
            return files;
        }

        return _.compact(_.map(files, (file) => {
            if (file.replace(baseDir, '')) {
                return file;
            } else {
                return null;
            }
        }));
    }

    _stat(files) {
        let result = [
            [],
            []
        ];
        _.each(files, function (file) {
            file = _.extend(fs.statSync(file), {src: file});
            if (file.isDirectory()) {
                result[0].push(file);
            } else {
                result[1].push(file);
            }
        });
        return result;
    }

    /**
     * 搜索文件夹下所有文件
     * @param patterns 文件正则
     * @returns {*}
     * @private
     */
    _glob(patterns) {
        let include = [],
            exclude = [];

        if (!_.isArray(patterns)) {
            patterns = [patterns];
        }
        patterns.forEach(function (pattern) {
            if (pattern.indexOf('!') === 0) {
                exclude = exclude.concat(glob.sync(pattern.substring(1), {nonull: false}) || []);
            } else {
                include = include.concat(glob.sync(pattern, {nonull: false}) || []);
            }
        });

        return _.difference(include, exclude);
    }

    /**
     * 切换到指定路径
     * @param path
     * @param callback
     * @private
     */
    _cwd(path, callback) {
        this.ftp.mkdir(path, true, (err) => {
            if (err) {
                log(err, 'debug');
            }
            this.ftp.cwd(path, function (err) {
                if (err) log(err, 'debug');
                callback();
            });
        });
    }
}

module.exports = FTPClient;

const client = new Ftpclient();

client.connect(function () {
    client.upload(['E:/test//**'], '/media/test', {
        baseDir: 'E:/test/',
        overwrite: 'older'
    }, function (result) {
        console.log(result);
    });
})