poi/tasks/bootstrap.coffee

gulp     = require 'gulp'
path     = require 'path'
inquirer = require 'inquirer'
fs       = require 'fs'
chalk    = require 'chalk'
{spawn}  = require 'child_process'

{log, spinner} = require './util'

# TODO This should move away from here, obviously
boilerplates =
  backend:
    node: 'https://github.com/poi/node'
    rails: 'https://github.com/poi/rails'
  frontend:
    static: 'https://github.com/poi/static'
  service:
    redis: 'https://github.com/poi/redis'


# TODO Use an actual package?
git = (args...) ->
  spawn 'git', args

bootstrap = (repo, name, done) ->
  # TODO handle failed git clones
  child = if repo
    git 'clone', repo, name
  else
    git 'init', name

  child.on 'close', (err) ->
    done err, {repo, name}

confirm = (done) ->
  inquirer.prompt [
    type: 'confirm'
    name: 'ok'
    message: 'Is that ok?'
  ], ({ok}) ->
    if not ok
      log.error "Aborted."
      return done "Aborted"
    done()


prompts =
  name: (default_) ->
    name: 'name'
    message: "Name?"
    default: default_
    validate: (value) ->
      switch
        when not value
          "Needs a name"
        when -1 < value.indexOf ' '
          "No spaces!"
        when fs.existsSync path.join process.cwd(), value
          "'#{value}' exists already in this directory"
        else
          true

wizards =
  index: (done) ->
    log.info "Let's build something!"

    inquirer.prompt [
      type: 'list'
      name: 'type'
      message: 'What do you want to build?'
      choices: [
        'app'
        'module'
        'clone'
      ]
    ], ({type}) ->
      wizards[type] done

  repo: (done) ->
    log.info "Let's build a clone!"

    inquirer.prompt [
      name: 'base'
      message: "Repository url?"
    ,
      prompts.name ({repo}) -> path.basename repo
    ], ({repo, name}) ->
      bootstrap repo, name, done

  module: (done) ->
    log.info "Let's build a module!"

    inquirer.prompt [
      prompts.name()
    ,
      type: 'list'
      name: 'type'
      message: 'What for?'
      choices: [
        name: 'bower componenet'
        value: 'bower'
      ,
        name: 'npm package'
        value: 'npm'
      ,
        name: 'ruby gem'
        value: 'gem'
      ]
    ], ({type}) ->
      log.warn "Too bad, can't do that yet!"


  app: (done) ->
    log.info "Let's build an app!"

    inquirer.prompt [
      name: 'type'
      type: 'list'
      message: "Type?"
      choices: [
        'frontend'
        'backend'
        'split-stack'
        'service'
        'repo'
        'blank'
      ]
    ,
      prompts.name()
    ,
      when: ({type}) -> type == 'backend'
      type: 'list'
      name: 'repo'
      message: "Backend?"
      choices: (name: name, value: boilerplates.backend.node for name in [
        'node'
        'rails'
      ])
    ,
      when: ({type}) -> type == 'service'
      type: 'list'
      name: 'repo'
      message: "Service?"
      choices: [
        name: 'redis'
        value: boilerplates.service.redis
      ]
    ,
      when: ({type}) -> type == 'repo'
      name: 'repo'
      message: "Repository url?"
    ], ({name, type, repo}) ->

      log.info "About to create", chalk.white(type), "project", chalk.white(name)

      confirm (err) ->
        return done err if err

        bootstrap repo, name, done

gulp.task "bootstrap:app", wizards.app
gulp.task "bootstrap:module", wizards.module
gulp.task "bootstrap:repo", wizards.repo
gulp.task "bootstrap:wizard", wizards.index

module.exports = wizards