#!/usr/bin/python
# sim-manage -- manage simulations.
#
# Michael Thomas <mthomas@cct.lsu.edu>
# Center for Computation & Technology
# Louisiana State University 
#

import sys, os, time, tempfile

############################################
## APP SPECIFIC DEFINES ##
#
# Usage			when (-h, --help) is used, this is the first line showing how to call the app
# optionGroups	which option groups from etc/options to import. common is always imported. 

App = "sim-manage"
Usage = "usage: %prog [options] command simulationname"
optionGroups = ['sim-manage']
Purpose = "manage an ADCIRC+Swan process"

############################################

############################################
## INIT ##

if os.path.basename(sys.argv[0]) == App:
	rp = os.path.abspath(__file__)
	
	paths = rp.split(os.sep)

	paths.pop()
	paths.pop()
	
	global BASE_PATH
	BASE_PATH = os.sep.join(paths)
	sys.path.append(BASE_PATH)
	
	LIB_PATH = "%s%slib" % (BASE_PATH, os.sep)
	
	sys.path.append(LIB_PATH)

from lib import *

import libutil
from libutil import dprint

## lets go to work

known_commands = ['create', 'submit', 'run', 'interactive', 'stop', 'archive', 
				'show-output', 'create-submit', 'create-run', 'purge', 'run-debug', 'get-output-dir']
usage_strings = {
				'create': 'create a simulation', 
				'submit': 'submit a simulation', 
				'create-submit': 'create and submit a simulation',
				'create-run': 'create and run a simulation',
				'run': 'launch a simulation', 
				'interactive': 'initiate an interactive session on a compute node',
				'stop': 'stop an active simulation',
				'show-output': 'show the output of a simulation',
				'archive': 'archive a simulation or an individual restart',
				'run-debug': 'launch simulation using an interactive debugger',
				'purge': 'purge a simulation',
				'get-output-dir': 'get the output directory of a given simulation'}

def buildUsageString():
	global Usage
	
	cmdString = "%s\n\n\nAvailable Commands:\n" % Usage
	iString = []
	
	for kk in known_commands:
		ss = "  %-35s%s" % (kk, usage_strings[kk])
		iString.append(ss)
	
	cmdString = "%s%s" % (cmdString, "\n".join(iString))
	return cmdString
	
############################### MAIN ###############################

def command_purge():
	global SimEnvironment
	global OptionsManager
	global SimLib
	
	if len(OptionsManager.args) == 0:
		dprint("Error: no simulation name specified")
		dprint("Usage: %s purge <simulationname> <simulationname> ..." % sys.argv[0])
		sys.exit(1)
		
	for simulationName in OptionsManager.args:
		simulationName = OptionsManager.args.pop(0)
	
		dprint("Simulation name: %s" % simulationName)
		
		restart = simrestart.SimRestart(SimEnvironment)
		
		ret = restart.load(simulationName)
		
		if ret == -1:
			dprint("Error: unable to load simulation %s for purging" % simulationName)
			sys.exit(1)
		
		restart.trash()

def command_get_output_dir():
	
	global SimEnvironment
	global OptionsManager
	global SimLib
	
	simulationName = None
	
	if simulationName == None:
		simulationName = OptionsManager.args.pop(0)
		dprint("Simulation name: %s" % simulationName)
	
	restart = simrestart.SimRestart(SimEnvironment)
	
	restart.load(simulationName)
	
	restart_id = 0
	
	if OptionsManager.HasOption('restart-id'):
		restart_id = OptionsManager.GetOption('restart-id')
	else:
		restart_id = SimEnvironment.RestartLib.GetMaxRestartID(restart)
	
	restart.loadFromRestartId(restart_id)
	
	output_dir = SimLib.BuildPath([restart.RestartDir, 'work'])

	dprint("Output directory: %s" % output_dir, libutil.ALWAYS_PRINT)
	
def command_interactive():
	
	global SimEnvironment
	global OptionsManager
	global SimLib
	
	restart = simrestart.SimRestart(SimEnvironment)
	restart.interactive()
	
def command_create():

	global SimEnvironment
	global OptionsManager
	global SimLib
	
	if SimEnvironment.APP_PATH == None:
		dprint("Error: cannot proceed with unknown APP_PATH")
		sys.exit(1)
	
	simulationName = None
	
	if simulationName == None:
		if len(OptionsManager.args) == 0:
			dprint("Error: no simulation name specified")
			sys.exit(1)
			
		simulationName = OptionsManager.args.pop(0)
		dprint("Simulation name: %s" % simulationName)

	
	restart = simrestart.SimRestart(SimEnvironment)
	restart.create(simulationName)

def command_create_submit():
	
	simulationName = None
	
	if simulationName == None:
		simulationName = OptionsManager.args[0]
		dprint("Simulation name: %s" % simulationName)
	else:
		OptionsManager.args.insert(0, simulationName)
		
	command_create()
	
	#reinsert our simulationname since command_create popped it off.
	OptionsManager.args.insert(0, simulationName)
	
	command_submit()

def command_create_run():
	
	simulationName = None
	
	if simulationName == None:
		simulationName = OptionsManager.args[0]
		dprint("Simulation name: %s" % simulationName)
	else:
		OptionsManager.args.insert(0, simulationName)
		
	command_create()
	
	#reinsert our simulationname since command_create popped it off.
	OptionsManager.args.insert(0, simulationName)
	
	command_run()
	
def command_run():
	global SimEnvironment
	global OptionsManager
	global SimLib
	
	simulationName = None
	
	if simulationName == None:
		simulationName = OptionsManager.args.pop(0)
		dprint("Simulation name: %s" % simulationName)
	
	restart = simrestart.SimRestart(SimEnvironment)
	
	ret = restart.load(simulationName)
	
	if ret == -1:
		dprint("Error: unable to load simulation %s for execution" % simulationName)
		sys.exit(1)
		
	restart.run()
	
def command_run_debug():
	global SimEnvironment
	global OptionsManager
	global SimLib
	
	simulationName = None
	
	if simulationName == None:
		simulationName = OptionsManager.args.pop(0)
		dprint("Simulation name: %s" % simulationName)
	
	restart = simrestart.SimRestart(SimEnvironment)
	
	ret = restart.load(simulationName)
	
	if ret == -1:
		dprint("Error: unable to load simulation %s for execution" % simulationName)
		sys.exit(1)
		
	restart.run(debug=True)
	
def command_submit():
	global SimEnvironment
	global OptionsManager
	global SimLib
	
	simulationName = None
	
	if simulationName == None:
		simulationName = OptionsManager.args.pop(0)
		dprint("Simulation name: %s" % simulationName)
	
	restart = simrestart.SimRestart(SimEnvironment)
	restart.submit(simulationName)

def command_show_output():

	global SimEnvironment
	global OptionsManager
	global SimLib
	
	simulationName = OptionsManager.args.pop(0)
	
	dprint("Simulation name: %s" % simulationName)
	
	restart = simrestart.SimRestart(SimEnvironment)
	ret = restart.load(simulationName)
	
	if ret == -1:
		dprint("Error: unable to load simulation %s for output" % simulationName)
		sys.exit(1)
		
	restart.show_output()
	
def command_stop():
	global SimEnvironment
	global OptionsManager
	global SimLib
	
	RestartLib = SimEnvironment.RestartLib
	
	simulationName = OptionsManager.args.pop(0)
	
	dprint("Simulation name: %s" % simulationName)
	
	if OptionsManager.HasOption('restart-id'):
		restart_id = OptionsManager.GetOption('restart-id')
		restart = RestartLib.GetRestartByRestartId(simulationName, restart_id)
		restart.stop()
		return
	
	if OptionsManager.HasOption('job-id'):
		job_id = OptionsManager.GetOption('job-id')
		dprint("Have job_id: %s" % job_id)
		restart = RestartLib.GetRestartByJobId(simulationName, job_id)
		restart.stop()
		return
	
	RestartLib.StopAllActiveRestarts(simulationName)

def command_archive():
	global SimEnvironment
	global OptionsManager
	global SimLib
	
	RestartLib = SimEnvironment.RestartLib
	
	simulationName = OptionsManager.args.pop(0)
	
	dprint("Simulation name: %s" % simulationName)
	
	if OptionsManager.HasOption('restart-id'):
		restart_id = OptionsManager.GetOption('restart-id')
		restart = RestartLib.GetRestartByRestartId(simulationName, restart_id)
	else:
		restart = simrestart.SimRestart(SimEnvironment)
		ret = restart.load(simulationName)
	
		if ret == -1:
			dprint("Error: unable to load simulation %s for archiving" % simulationName)
			sys.exit(1)
	
	restart.archive()
	
def CommandDispatch():
	
	global SimEnvironment
	global OptionsManager
	global known_commands
	
	if SimEnvironment.COMMAND == None:
		command = OptionsManager.args.pop(0)
	else:
		command = SimEnvironment.COMMAND
	
	if command not in known_commands:
		dprint("Error: unknown command %s " % command)
		OptionsManager.PrintHelp()
		sys.exit(0)
	
	command = command.replace("-", "_")
	
	dprint("Executing command: %s" % command)
	exec("command_%s()" % command)

def RemoteExecute(machineName):
	global SimEnvironment
	
	RemoteEnvironment = simremote.RemoteEnvironment(SimEnvironment)
	RemoteEnvironment.init(machineName)
	RemoteEnvironment.ExecuteSameCommand(parrotArguments=True, stripArguments=['remotemachine'])
	
def main(env):

	global OptionsManager
	global ConfigurationDatabase
	global SimLib
	global DefineDatabase
	global SimEnvironment
	
	SimEnvironment = env
	
	SimEnvironment.RequireMachine()
	
	OptionsManager = SimEnvironment.OptionsManager
	ConfigurationDatabase = SimEnvironment.ConfigurationDatabase
	SimLib = SimEnvironment.SimLib
	DefineDatabase = SimEnvironment.DefineDatabase

	if OptionsManager.HasOption("remotemachine"):
		remoteMachine = OptionsManager.GetOption("remotemachine")
		dprint("Managing for remote machine: %s" % remoteMachine)
		RemoteExecute(remoteMachine)
		return
		
	cactusDir = SimEnvironment.APP_PATH
	dprint("Cactus Directory: %s" % cactusDir)
	
	if os.getcwd() != cactusDir:
		dprint("Current Working directory does not match Cactus sourcetree, changing to %s" % cactusDir)
		# make sure we're in the Cactus source directory, otherwise all of this will blow way up.
		os.chdir(cactusDir)
	
	############################################

	if os.path.basename(SimEnvironment.EXECUTABLE) == App:
		dprint("sim-manage: %s\n" % Purpose, True)
		
		dprint("defs: %s" % SimEnvironment.cdb)
		
		if SimEnvironment.udb != None:
			dprint("defs.local: %s" % SimEnvironment.udb)
		
		print
		
	
	dprint("SimEnvironment.COMMAND: %s" % SimEnvironment.COMMAND)
	if len(OptionsManager.args) < 2 and SimEnvironment.COMMAND == None:
		OptionsManager.PrintHelp()
		sys.exit(0)
	
	#normalize restarts.
	SimEnvironment.RestartLib.CleanupRestarts()

	SimEnvironment.ForceVerbose()
	
	CommandDispatch()

	SimEnvironment.ResetVerbose()
	
# only run if you are App
if os.path.basename(sys.argv[0]) == App:
	global SimEnvironment
	SimEnvironment = simenv.SimEnvironment(BASE_PATH, os.path.abspath(sys.argv[0]))
	SimEnvironment.initApp(usageString=buildUsageString(), optionGroups=optionGroups)

	main(SimEnvironment)