#!/usr/bin/env node

require('lego-colorful').colorful();
var path = require('path');
var resolve = path.resolve;
var program = require('commander');
var archy = require('archy');
var legorc = require('legorc');
var log = require('lego-log');
var exists = require('fs').existsSync;
var readJSON = require('fs-extra').readJSONSync;
var install = require('../lib/client').install;

program
  .option('-d, --depth <n>', 'set the depth to <n>', Infinity)
  .option('--no-color', 'disable colorful print')
  .parse(process.argv);

// color
log.config(program);

var cache = {};
var query = program.args[0];

// handle "lego tree class"
if (query) {
  // don't show lego install log message
  log.quiet = true;
  install.fetch(query, function(err, dest) {
    install({
      source: program.source,
      destination: dest + '/' + legorc.get('install.path') + '/',
      force: program.force,
      parallel: program.parallel,
      query: program.args
    }, function() {
      process.chdir(dest);
      log.quiet = false;
      console.log(indent(archy(color(tree('package.json')))));
    });
  });
  return;
}

var p = exists('package.json') && readJSON('package.json');
if (!p || !p.lego) {
  console.log();
  log.error('miss', 'package.json or "lego" key');
  process.exit(2);
}

console.log();
console.log(indent(archy(color(tree('package.json')))));

function tree(f, paths, depth) {
  depth = depth || 0;
  if (!f) return {};
  f = resolve(f);
  if (!exists(f)) {
    console.log('  can not find ' + path.relative(process.cwd(), f));
    return {};
  }
  var pkg = require(f);
  var installPath = legorc.get('install.path');

  paths = paths || [installPath, path.join(legorc.get('user.home'), '.lego', installPath)];

  var node = {};
  var title = pkg.name;
  node.label = title + '@' + pkg.version;

  if (cache[title] && cache[title] !== pkg.version) {
    cache[title] = 'conflict';
  }
  if (!cache[title]) {
    cache[title] = pkg.version;
  }

  if (++depth > program.depth) return node;

  if (pkg.lego && pkg.lego.dependencies) {
    var deps = pkg.lego.dependencies;

    deps = Object.keys(deps).map(function(key) {
      return {
        name: key,
        version: deps[key]
      };
    }).filter(function(key) {
      return key;
    });
    node.nodes = deps.map(function(parsed) {
      return tree(lookup(paths, parsed));
    });
  }
  return node;
}

function color(node) {
  if (node.nodes) {
    node.nodes = node.nodes.map(color);
  }
  if (node.label) {
    var bits = node.label.split('@');
    var title = bits[0];
    var version = bits[1];
    if (cache[title] === 'conflict') {
      node.label = title.to.yellow + ('@' + version).to.red;
      if (program.color === false) {
        node.label = '{' + title + '@' + version + '}';
      }
    } else {
      node.label = title.to.cyan + ('@' + version).to.grey;
    }
  }
  return node;
}

function lookup(paths, pkg) {
  var pkgfile;
  paths.some(function(f) {
    var fpath = path.join(f, pkg.name, pkg.version, 'package.json');
    if (exists(fpath)) {
      pkgfile = fpath;
      return true;
    }
  });
  if (!pkgfile) {
    log.error('package', pkg.name + '@' + pkg.version + ' not found');
    return null;
  }
  return pkgfile;
}

function indent(str) {
  return str.replace(/^/gm, '  ');
}