var cst      = require('../../../constants.js');
var Common   = require('../../Common.js');
var UX       = require('../CliUx');
var chalk    = require('chalk');
var async    = require('async');
var path     = require('path');
var fs       = require('fs');
var KMDaemon = require('../../Interactor/InteractorDaemonizer');
var KM       = require('./kmapi.js');
var Table    = require('cli-table');
var open     = require('../../tools/open.js');

module.exports = function(CLI) {

  function validateEmail(email) {
    var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    if (re.test(email) == false)
      throw new Error('Not an email');
    return email;
  }

  function validateUsername(value) {
    if (value.length < 6) {
      throw new Error('Min length of 6');
    }
    return value;
  };

  CLI.prototype.registerToKM = function() {
    var promptly = require('promptly');
    var self = this;

    function linkOpenExit(target_bucket) {
      KMDaemon.launchAndInteract(self._conf, {
        public_key : target_bucket.public_id,
        secret_key : target_bucket.secret_id
      }, function(err, dt) {
        open('https://app.keymetrics.io/#/r/' + target_bucket.public_id);
        setTimeout(function() {
          self.exitCli(cst.SUCCESS_EXIT);
        }, 100);
      });
    }

    /**
     * Login on Keymetrics
     * Link to the only bucket or list bucket for selection
     * Open Browser
     */
    function loginPrompt(cb) {
      (function retry() {
        promptly.prompt('Username or Email: ', function(err, username) {
          promptly.password('Password: ', { replace : '*' }, function(err, password) {
            KM.loginAndGetAccessToken({ username : username, password: password }, function(err) {
              if (err) {
                console.error(chalk.red.bold(err) + '\n');
                return retry();
              }
              KM.getBuckets(function(err, buckets) {
                if (err) {
                  console.error(chalk.red.bold(err) + '\n');
                  return retry();
                }

                if (buckets.length > 1) {
                  console.log(chalk.bold('Bucket list'));

                  var table = new Table({
                    style : {'padding-left' : 1, head : ['cyan', 'bold'], compact : true},
                    head : ['Bucket name', 'Plan type']
                  });

                  buckets.forEach(function(bucket) {
                    table.push([bucket.name, bucket.credits.offer_type]);
                  });

                  console.log(table.toString());
                  promptly.prompt('Type the bucket you want to link to: ', function(err, bucket_name) {
                    var target_bucket;

                    buckets.some(function(bucket) {
                      if (bucket.name == bucket_name) {
                        target_bucket = bucket;
                        return true;
                      }
                    });
                    linkOpenExit(target_bucket);
                  });
                }
                else {
                  var target_bucket = buckets[0];
                  console.log('Connecting local PM2 to Keymetrics Bucket [%s]', target_bucket.name);

                  KMDaemon.launchAndInteract(self._conf, {
                    public_key : target_bucket.public_id,
                    secret_key : target_bucket.secret_id
                  }, function(err, dt) {
                    linkOpenExit(target_bucket);
                  });
                }
              });
            });

          });
        })
      })()
    }

    /**
     * Register on Keymetrics
     * Create Bucket
     * Auto Link local PM2 to new Bucket
     * Open Browser for access to monitoring dashboard
     */
    function registerPrompt() {
      promptly.prompt('Username: ', {
        validator : validateUsername,
        retry : true
      }, function(err, username) {
        promptly.prompt('Email: ', {
          validator : validateEmail,
          retry : true
        }, function(err, email) {
          promptly.password('Password: ', { replace : '*' }, function(err, password) {
            process.stdout.write(chalk.bold('Creating account on Keymetrics..'));
            var inter = setInterval(function() {
              process.stdout.write('.');
            }, 300);
            KM.fullCreationFlow({
              email : email,
              password : password,
              username : username
            }, function(err, target_bucket) {
              clearInterval(inter);
              if (err) {
                console.error('\n' + chalk.red.bold(err) + '\n');
                return registerPrompt();
              }
              linkOpenExit(target_bucket);
            });
          });
        });
      })
    }

    promptly.confirm(chalk.bold('Do you have a Keymetrics.io account? (y/n)'), function (err, answer) {
      if (answer == true) {
        return loginPrompt();
      }
      registerPrompt();
    });

  };

  /**
   * Monitor Selectively Processes (auto filter in interaction)
   * @param String state 'monitor' or 'unmonitor'
   * @param String app_name <pm_id|name|all>
   * @param Function cb callback
   */
  CLI.prototype.monitorState = function(state, app_name, cb) {
    var that = this;

    try {
      fs.statSync(this._conf.INTERACTION_CONF);
    } catch(e) {
      Common.printError(cst.PREFIX_MSG_ERR + 'Not linked to Keymetrics');
      return cb ? cb(new Error('Not linked to Keymetrics')) : that.exitCli(cst.ERROR_EXIT);
    }

    function monitor(pm_id, cb) {
      // State can be monitor or unmonitor
      that.Client.executeRemote(state, pm_id, function(err, ret) {
        return cb();
      });
    }

    if (app_name == 'all') {
      return that.Client.getAllProcessId(function(err, procs) {
        if (err) {
          Common.printError(err);
          return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
        }
        async.forEachLimit(procs, 1, function(pm_id, next) {
          monitor(pm_id, next);
        }, function() {
          return cb ? cb.apply(null, arguments) : that.speedList();
        });
      });
    }

    if (isNaN(app_name)) {
      return this.Client.getProcessIdByName(app_name, function(err, procs) {
        if (err) {
          Common.printError(err);
          return cb ? cb(Common.retErr(err)) : that.exitCli(cst.ERROR_EXIT);
        }
        async.forEachLimit(procs, 1, function(pm_id, next) {
          monitor(pm_id, next);
        }, function() {
          return cb ? cb.apply(null, arguments) : that.speedList();
        });
      });
    }

    monitor(app_name, function() {
      return cb ? cb.apply(null, arguments) : that.speedList();
    });
  };

};