/*
 *
 * This tests a flow for cloudron owner creating a selfhosted cloudron on digitalocean
 * Owner creates a cloudron, activates it, installs and app and deletes the cloudron eventually
 * We use a us-east-1 (US standard) backup bucket here
 *
 */

'use strict';

var AppStore = require('../appstore.js'),
    assert = require('assert'),
    async = require('async'),
    child_process = require('child_process'),
    Cloudron = require('../cloudron.js'),
    common = require('../common.js'),
    digitalocean = require('../digitalocean.js'),
    mailer = require('../mailer.js'),
    rimraf = require('rimraf'),
    semver = require('semver'),
    sleep = require('../shell.js').sleep,
    superagent = require('superagent'),
    request = require('superagent-sync'),
    util = require('util');

require('colors');

process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
const BOX_VERSION = process.env.BOX_VERSION;
const DO_SELFHOST_DOMAIN = process.env.DO_SELFHOST_DOMAIN;
const DO_SSH_KEY = 'e2e_selfhost';
const DO_TYPE = '1gb';
const DO_REGION = 'nyc3';
const DO_IMAGE_SLUG = 'ubuntu-16-04-x64';
const BACKUP_KEY = 'somesecret';
const BACKUP_FOLDER = '/tmp/' + process.env.DO_SELFHOST_DOMAIN;

function machine(args, options) {
    // https://github.com/nodejs/node-v0.x-archive/issues/9265
    options = options || { };
    args = util.isArray(args) ? args : args.match(/[^\s"]+|"([^"]+)"/g);
    args = args.map(function (e) { return e[0] === '"' ? e.slice(1, -1) : e; }); // remove the quotes

    console.log('cloudron machine ' + args.join(' '));

    try {
        var cp = child_process.spawnSync('cloudron', ['machine'].concat(args), { stdio: [ options.stdin || 'pipe', options.stdout || 'pipe', 'pipe' ], encoding: options.encoding || 'utf8' });
        return cp;
    } catch (e) {
        console.error(e);
        throw e;
    }
}

function cloudronCommand(args, options) {
    // https://github.com/nodejs/node-v0.x-archive/issues/9265
    options = options || { };
    args = util.isArray(args) ? args : args.match(/[^\s"]+|"([^"]+)"/g);
    args = args.map(function (e) { return e[0] === '"' ? e.slice(1, -1) : e; }); // remove the quotes

    console.log('cloudron ' + args.join(' '));

    try {
        var cp = child_process.spawnSync('cloudron', args, { stdio: [ options.stdin || 'pipe', options.stdout || 'pipe', 'pipe' ], encoding: options.encoding || 'utf8' });
        return cp;
    } catch (e) {
        console.error(e);
        throw e;
    }
}

describe('Selfhost DigitalOcean with filesystem backend', function () {
    this.timeout(0);

    var appStore = new AppStore();

    var owner = common.getOwner();
    var cloudron, appId, backupInfo, instanceId, restoreInstanceId, migrateInstanceId;
    var fromVersion, toVersion, nextVersion;

    digitalocean.setCredentials(process.env.DIGITAL_OCEAN_TOKEN_STAGING);

    it('can query versions', function () {
        var res = request.get(process.env.BOX_VERSIONS_URL).end();
        common.verifyResponse2xx(res);
        var boxVersions = Object.keys(common.stripUnreachable(res.body)).sort(semver.rcompare);
        fromVersion = boxVersions[2]; // we released a new version in before.js
        toVersion = boxVersions[1];
        assert.strictEqual(toVersion, BOX_VERSION);
        nextVersion = boxVersions[0];

        console.log('Will test update from %s to %s and then %s', fromVersion.yellow, toVersion.yellow, nextVersion.yellow);
    });

    it('can create a cloudron', function (done) {
        digitalocean.create('tselfhost-filesystem-test', DO_IMAGE_SLUG, DO_SSH_KEY, DO_REGION, DO_TYPE, '', function (error, result) {
            if (error) return done(error);

            instanceId = result.id;
            console.log('New instance created with id', instanceId);

            var ip = null;

            function waitForSSH() {
                var params = [
                    '--cloudron ' + cloudron._box.ip,
                    '--ssh-key ' + DO_SSH_KEY,
                    '--ssh-port 22'
                ];

                var out = machine('ssh ' + params.concat(['echo "hello"']).join(' '));
                if (out.status === 0) return done();

                setTimeout(waitForSSH, 2000);
            }

            function waitForDroplet() {
                digitalocean.get(result.id, function (error, result) {
                    if (error) return done(error);

                    console.log('status', result.status);

                    ip = result.ip;

                    if (result.status === 'active') {
                        cloudron = new Cloudron({
                            domain: DO_SELFHOST_DOMAIN,
                            setupToken: null,
                            version: toVersion,
                            ip: result.ip
                        });

                        return waitForSSH();
                    }

                    setTimeout(waitForDroplet, 2000);
                });
            }

            waitForDroplet();
        });
    });

    it('can install the Cloudron', function () {
        var params = [
            '--cloudron ' + cloudron._box.ip,
            '--ssh-key ' + DO_SSH_KEY,
            '--ssh-port 22'
        ];

        console.log('wget cloudron-setup');
        var out = machine('ssh ' + params.concat(['wget https://cloudron.io/cloudron-setup']).join(' '));
        console.log(out.stdout, out.stderr);
        assert.strictEqual(out.status, 0);

        console.log('chmod +x cloudron-setup');
        out = machine('ssh ' + params.concat(['chmod +x cloudron-setup']).join(' '));
        console.log(out.stdout, out.stderr);
        assert.strictEqual(out.status, 0);

        console.log('run cloudron-setup');
        out = machine('ssh ' + params.concat(['"./cloudron-setup --provider digitalocean --prerelease --version ' + toVersion + ' --env staging --skip-reboot"']).join(' '));
        console.log(out.stdout, out.stderr);
        assert.strictEqual(out.status, 0);

        console.log('reboot the server');
        out = machine('ssh ' + params.concat(['systemctl reboot']).join(' '));
        console.log(out.stdout, out.stderr);
    });

    it('can setup dns', function () {
        cloudron = new Cloudron({
            domain: DO_SELFHOST_DOMAIN,
            setupToken: null,
            version: toVersion,
            ip: cloudron._box.ip
        });

        var dnsConfig = {
            domain: process.env.DO_SELFHOST_DOMAIN,
            provider: 'digitalocean',
            token: process.env.DIGITAL_OCEAN_TOKEN_STAGING
        };

        cloudron.waitForBox(true);
        cloudron.setupDns(dnsConfig);
    });

    it('can activate the box', function () {
        cloudron.activate(owner);
    });

    it('can login to the box', function () {
        var token = cloudron.getOauthToken(owner);
        cloudron.setCredentials(owner.password, token);

        var params = [
            process.env.DO_SELFHOST_DOMAIN,
            '--username ' + owner.username,
            '--password ' + owner.password
        ];

        var out = cloudronCommand('login ' + params.join(' '));
        console.log(out.stdout, out.stderr);

        assert.strictEqual(out.status, 0);
    });

    it('can take a breather', function () {
        // do can be really slow to come up. the addon containers take their own sweet time (they are "async" with the box startup)
        // we end up sending email even before the mail container is ready
        sleep(30);
    });

    it('can enable email', function () {
        cloudron.setEmailEnabled(true);
    });

    it('send mail to cloudron user', function (done) {
        mailer.sendMailToCloudronUser(owner.username + '@' + DO_SELFHOST_DOMAIN, done);
    });

    it('did receive mail', function (done) {
        cloudron.checkMail(owner, done);
    });

    var location = 'test' + (Math.random() * 10000).toFixed();
    it('can install app', function () {
        var manifest = appStore.getManifest(common.TESTAPP_ID, common.TESTAPP_VERSION);
        appId = cloudron.installApp(location, manifest);
    });

    it('can populate the addons', function () {
        cloudron.populateAddons(cloudron.appFqdn(location));
    });

    it('can check the addons', function () {
        cloudron.checkAddons(cloudron.appFqdn(location), owner);
    });

    it('can set appstore config', function (done) {
        var token = appStore.getAccessToken(owner);
        appStore.setCredentials(owner.password, token);
        var profile = appStore.getProfile();
        console.dir(profile);
        cloudron.setAppstoreConfig(profile.id, token);
    });

    it('can update the box', function () {
        cloudron.checkForUpdates();

        var params = [
            '--cloudron ' + process.env.DO_SELFHOST_DOMAIN,
            '--ssh-key ' + DO_SSH_KEY,
            '--ssh-port 22'
        ];

        var out = machine('update ' + params.join(' '));
        console.log(out.stdout, out.stderr);

        if (out.stdout.indexOf('Update successful') === -1) {
            assert(false, 'Update failed');
        }
    });

    it('wait for app to be ready', function () {
        cloudron.waitForApp(appId);
    });

    it('can configure app', function () {
        location = location + 'x';
        cloudron.configureApp(appId, location);
    });

    it('can check the addons', function () {
        cloudron.checkAddons(cloudron.appFqdn(location), owner);
    });

    it('can check dnsbl', function () {
        cloudron.checkDnsbl(cloudron.appFqdn(location));
    });

    it('can reboot the cloudron', function () {
        cloudron.reboot();
    });

    it('runs the app', function () {
        cloudron.waitForApp(appId);
    });

    it('can check the addons', function () {
        cloudron.checkAddons(cloudron.appFqdn(location), owner);
    });

    it('can check dnsbl', function () {
        cloudron.checkDnsbl(cloudron.appFqdn(location));
    });

    it('can check mail', function (done) {
        cloudron.checkMail(owner, done);
    });

    it('can backup the box', function () {
        backupInfo = cloudron.backup();
        assert.strictEqual(backupInfo.dependsOn.length, 1);
    });

    it('can list backups', function () {
        var out = machine('backup list --cloudron ' + DO_SELFHOST_DOMAIN);
        console.log(out.stdout, out.stderr);

        var knownBackupIds= out.stdout.split('\n').filter(function (l) { return l.indexOf('box_') >= 0; }).map(function (l) { return l.split(' ')[0].trim(); });

        console.log('Last backup ids:', knownBackupIds);

        assert(knownBackupIds.some(function (id) { return id === backupInfo.id; }));
    });

    it('can download backups', function () {
        var out = machine('backup download ' + DO_SELFHOST_DOMAIN + ' --backup-id ' + backupInfo.id + ' ' + BACKUP_FOLDER);
        console.log(out.stdout, out.stderr);

        if (out.stdout.indexOf(backupInfo.id) === -1) assert(false, 'Download failed');

        // TODO verify the md5sum
    });

    // it('can restore the box', function () {
    //     var params = [
    //         '--fqdn ' + DO_SELFHOST_DOMAIN,
    //         // THOSE SHOULD BE STASHED IN THE CONFIG
    //         // '--type ' + DO_TYPE,
    //         // '--token ' + DO_TOKEN,
    //         // '--region ' + DO_REGION,
    //         // '--ssh-key ' + SSH_KEY,
    //         // '--backup-key ' + BACKUP_KEY,
    //         '--backup ' + backupInfo.id,
    //         '--backup-folder ' + BACKUP_FOLDER
    //     ];

    //     var out = machine('restore digitalocean ' + params.join(' '));
    //     console.log(out.stdout, out.stderr);

    //     if (out.stdout.indexOf('You can now use your Cloudron at') === -1) {
    //         assert(false, 'Restore failed');
    //     }

    //     restoreInstanceId = out.stdout.split('\n').filter(function (l) { return l.indexOf(' ID: ') !== -1; })[0].split(':')[1].trim();

    //     console.log('New instance created with ID', restoreInstanceId);

    //     rimraf.sync(BACKUP_FOLDER);
    // });

    it('runs the app', function () {
        cloudron.waitForApp(appId);
    });

    it('can uninstall app', function () {
        cloudron.uninstallApp(appId);
    });

    it('can delete the cloudron', function (done) {
        console.log('Cleanup DO instances', instanceId, restoreInstanceId, migrateInstanceId);

        // we ignore errors here
        function deleteDroplet(id, callback) {
            if (!id) return callback();

            digitalocean.destroy(id, function (error) {
                if (error) console.error(error.message);
                callback();
            });
        }

        async.each([ instanceId, restoreInstanceId, migrateInstanceId ], deleteDroplet, done);
    });
});