kd/lib/kdkite.coffee

_ = require 'underscore'
fs      = require 'fs-extra'
os = require 'os'
path    = require 'path'
shell   = require "shelljs"
helpers = require '../modules/common/helpers'
Processes = require '../lib/processes'
EventEmitter = require("events").EventEmitter
{spawn} = require 'child_process'
{findFile, guard} = require '../modules/common/helpers'
urlp = require 'url'


url = 
  isAbsolutePath: (s)->
    s.indexOf '/' > 0
  
  isRelativePath: (s)->
    s.indexOf('./') > 0 or s.indexOf('../') > 0

  isGitRepo: (s)->
    s.indexOf('git@') >=0 and s.indexOf('.git') > 0

  isZipUrl: (s)->
    s.indexOf('http://') >=0 or s.indexOf('https://')>0

class Installer
  constructor:(@from, @basedir)->

  getKite:(callback)=>
    if fs.existsSync @to and fs.existsSync path.join(@to, 'manifest.json')
      callback new KDKite(@to)
    else
      @install(callback)

class ZipInstaller extends Installer
  install: (callback)->
    pass

  @test: (src)->
    url.isZipUrl(src)

class GitInstaller extends Installer

  constructor:(@from, @basedir)->
    @kiteDir = @getRepoNameFromUrl(@from)
    @to = path.normalize(path.join(@basedir, 'kites', @kiteDir))

  getRepoNameFromUrl: (s) ->
    /\/(.*)\.git$/.exec(s)[1].split('.kite')[0]

  install:(callback)->
    guard (not shell.which "git"), "You need git to install dependencies."
    repoUrl = urlp.parse @from
    unless repoUrl.hostname
      console.log "Installing: ", @to
      shell.mkdir "-p", @to
      shell.exec "git clone --recursive -q #{@from} #{@to}", (err, res)->
        console.log "#{@to} installed."
        callback()

  @test: (src)->
    url.isGitRepo(src)


class FileSystemInstaller extends Installer

  constructor:(@from, @basedir)->
    @to = path.normalize(path.join(@basedir, 'kites', path.basename(@from)))

  install:(callback)=>
    # installs kite from the given path, by copying all the files..
    fs.mkdirs @to, (err)=>
      guard err, "directory create failure", err
      fs.copy @from, @to, (err)=>
        if err
          console.log "Error:", err
          callback(err)
        kite = new KDKite(@to)
        callback(false, kite)

  @test: (src)->
    url.isAbsolutePath(src)

getInstallerClass = (url)->
  installers = [ZipInstaller, GitInstaller, FileSystemInstaller]
  for i in installers
    try
      if i.test(url)
        return i
    catch E
      console.log E


module.exports = class KDKite extends EventEmitter

  constructor: (dir)->
    @dir = dir
    @dependencies = []

  cloneFrom: (skel, callback)->
    env = 
      name: @name,
      username: @username
      mail: @mail
      version: @version

    helpers.createSkeleton
      skel: skel
      toPath: @dir
      env: env
      callback: (err)=>
        console.log "err: ", err
        callback(err)

  prepare: (callback)=>
    @manifest = @getManifest =>
      @findDependencies (err, deps)=>
        guard err, "Error when installing dependency"
        @emit "ready"
        if callback
          callback(false, @)

  removeDependency: (depPath, callback)->
    getManifest =>
      @manifest.dependencies = _.reject @manifest.dependencies, (el)-> el == depPath
      @saveManifest callback

  addDependency: (p, callback)->
    @getManifest =>
      if p not in @manifest.dependencies
        @manifest.dependencies.push p
        @saveManifest callback
      else
       callback()

  saveManifest: (callback)->
    data = JSON.stringify @manifest, null, "\t"
    fs.writeFile @manifestPath.fullpath, data, (err)=>
      guard err, "Couldn't save manifest file", err
      callback(err)

  getManifest: (callback)->
    @manifestPath = findFile @dir, ['.manifest', 'manifest.json']
    guard not @manifestPath, "Couldn't find your manifest file - #{@dir}"

    fs.readFile @manifestPath.fullpath, 'utf-8', (err, content)=>
      guard err, "Couldnt read your manifest file, io error", err
      try
        @manifest = JSON.parse content
      catch E
        console.log "Error in your manifest file"
        throw E
      @name     = @manifest.name 
      @version  = @manifest.version
      @username = @manifest.username
      @mail     = @manifest.mail
      callback()

  findDependencies: (callback) ->
    # dependencies are some other kites in a tree based structure
    # mykite
    # \_> someotherkite
    #       \_> another kite
    # this finds the dependencies, and installs them as needed
    if @manifest.dependencies?.length > 0
      cb = 0
      for source in @manifest.dependencies
        klass = getInstallerClass(source)
        installer = new klass(source, @dir)
        try
          cb++
          installer.getKite (err, kite)=>
            kite.prepare (err, kite)=>
              @dependencies.push kite
              cb--
        catch e
          console.log "error", e
      interval = setInterval =>
        if cb is 0
          callback(false, @dependencies)
          clearInterval interval
      , 0
    else
      callback(false,[])

  listDependencies:(depth=0)->
    @getManifest =>

      pad = ""
      for i in [0..(depth*2)]
        pad += " "        
      
      if @manifest.dependencies?.length > 0
        for dep in @manifest.dependencies
          console.log "#{pad}", dep
          toPath = @getRealPathFromDependency(dep)
          depKite = new KDKite(toPath)
          depKite.listDependencies(depth+1)


  npm: (callback)->
    curDir = process.cwd()
    process.chdir(@dir)
    install = spawn "npm", ["install"]
    install.stdout.on "data", (data)-> process.stdout.write data
    install.stderr.on "data", (data)-> process.stdout.write data
    install.on "close", ->
      process.stdout.write os.EOL
      process.chdir(curDir)
      callback()

  spawn: (executable, entryPoint, args)=>
    args = [entryPoint].concat args
    @processes.spawn {cmd:executable, args, verbose:true, name:path.basename(@dir)}, (err, child)->
      guard err, "Couldn't run kite #{err}"
      console.log "now running the kite", entryPoint

  run:(options)=>

    tryFiles = (paths)->
      for p in paths
        if fs.existsSync p
          return p

    # TODO: which didnt work in vagrant/lxc, thats why this is here.
    coffeePath = tryFiles ["/usr/bin/coffee","/usr/local/bin/coffee"]
    console.log "coffeePath", coffeePath
    nodeJsPath = tryFiles ["/usr/bin/nodejs", "/usr/local/bin/nodejs"]

    @npm =>  
      # do we have a coffee file or js file for index.
      executablesMap = {'index.coffee': coffeePath, 'index.js': nodeJsPath}
      entryPoint = findFile(@dir, executablesMap)
      guard not entryPoint, "Can't find your index.coffee or index.js file"
      executable = executablesMap[entryPoint.key]
      guard not executable, "cant find executable for " + JSON.stringify(executablesMap)

      for dep in @dependencies
        dep.processes = @processes
        dep.prepare (err, obj)->
          console.log "!!!!! prepared", obj.dir
          obj.run()
      @spawn executable, entryPoint.fullpath, ['--messagebusport', options.messageBusPort]