#!/usr/bin/coffee

fs = require 'fs'
async = require 'async'
af = require './api.coffee'

token_file = "#{process.env.HOME}/.af-coffee-token"

timeout = (ms, f) -> setTimeout f, ms

# a session caches the api access token and prompts for the username and
# password if it goes stale. It re-tries API calls that fail due to
# invalid/expired token

commands = {}
for k, v of af
	commands[k] = v unless k is 'login'

# this is the friendly one that updates the files then restarts the app
commands.app_publish = (token, app_name, zip_file, callback) ->
	async.waterfall [
		(callback) =>      @api 'app_update_files', app_name, zip_file, callback
		(res, callback) => @api 'app_restart',      app_name, callback
	], callback

app_set_state = (token, app_name, state, callback) ->
	async.waterfall [
		(callback) =>
			@api 'app_info', app_name, callback
		(info, callback) =>
			info.state = state
			@api 'app_set_info', app_name, info, callback
	], callback

commands.app_start = (token, app_name, callback) ->
	app_set_state.call this, token, app_name, 'STARTED', callback

commands.app_stop = (token, app_name, callback) ->
	app_set_state.call this, token, app_name, 'STOPPED', callback


commands.app_restart = (token, app_name, callback) ->
	# Server requires you to fetch the app state before each call to change
	# it, so there's no quicker way than just calling app_stop then app_start
	async.waterfall [
		(callback) =>      @api 'app_stop',  app_name, callback
		(res, callback) => @api 'app_start', app_name, callback
	], callback



class Session
	constructor: ->
		@token = 0
		@verbose = true
		@log_nest = 0
		@log_mid = false

	log_whitespace: ->
		out = ''
		out += '\n' if @log_mid
		for i in [0...@log_nest]
			out += '\t'
		return out

	log_start: (msg) ->
		return unless @verbose
		process.stdout.write "#{@log_whitespace()}#{msg}"
		@log_nest += 1
		@log_mid = true

	log_end: ->
		return unless @verbose
		@log_nest -= 1
		if @log_mid
			process.stdout.write "... done\n"
		else
			process.stdout.write "#{@log_whitespace()}done\n"
		@log_mid = false

	api: (call, args..., callback) ->
		async.waterfall [
			(callback) =>
				switch @token
					when 0
						get_token callback
					when -1
						login.call this, callback
					else
						callback null, @token
			(token, callback) =>
				@token = token
				@log_start [call, args...].join ' '
				# commands implemented in client.coffee need "this" pointing to the session
				commands[call].call this, @token, args..., (err, the_rest...) =>
					@log_end() unless err?
					callback err, the_rest...
		], (err, result) =>
			# eg /app/xxx/stats sometimes returns 404 with wrong auth token
			if err?.code is 403 or err?.code is 404
				@token = -1
				@api(call, args..., callback)
			else
				callback err, result

	ask: (opts, callback) ->
		process.stdout.write @log_whitespace() + opts.prompt
		process.stdin.setEncoding 'utf8'
		process.stdin.resume()
		process.stdin.once 'data', (line) =>
			if opts.silent
				# send ^[[A^[[2K to move the cursor up one line, then clear that line
				process.stdout.write new Buffer [27, 91, 65, 27, 91, 50, 75]
				process.stdout.write @log_whitespace() + opts.prompt + "***\n"
			process.stdin.pause()
			@log_mid = false
			callback null, (line.substr 0, line.length - 1)

get_token = (callback) ->
	fs.readFile token_file, 'utf8', (err, token) ->
		if err?
			login callback
		else
			callback null, token

login = (callback) ->
	async.waterfall [
		(callback) => async.series [
			(callback) => @ask prompt: 'username: ', callback
			(callback) => @ask prompt: 'password: ', silent: true, callback
		], callback
		([username, password], callback) ->
			af.login username, password, callback
		(token, callback) ->
			# wait for file write so there's no race condition if get_token gets called soon
			fs.writeFile token_file, token, (err) ->
				if err
					process.stderr.write "Warning: couldn't cache auth token in #{token_file}: #{err}\n"
				# don't pass on error, it's ok if we can't cache it
				callback null, token
	], callback


exports.new_session = ->
	return new Session()

usage = ->
	process.stderr.write "usage: #{process.argv[0]} #{process.argv[1]} command [args...]\n"
	process.stderr.write "valid commands are:\n\t#{(k for k, v of commands).join '\n\t'}\n"

# parse and act on commandline arguments unless we were require()d as a module
if require.main is module
	args = process.argv[2..]
	if args.length is 0
		usage()
	else if not commands[args[0]]
		process.stderr.write "unknown command \"#{args[0]}\"\n"
		usage()
	else
		session = new Session()
		session.api args[0], args[1..]..., (err, result) ->
			if err?
				process.stderr.write "Error: #{JSON.stringify err}\n"
			if result?
				if typeof result is 'string'
					process.stdout.write result
				else
					process.stdout.write JSON.stringify result