import os, sys, re
import libutil
from libutil import dprint

import socket

class RemoteEnvironment:
	def __init__(self, env):
		# we need SimEnvironemtn
		self.SimEnvironment = env
		self.OptionsManager = self.SimEnvironment.OptionsManager
		self.ConfigurationDatabase = self.SimEnvironment.ConfigurationDatabase
		self.DefineDatabase = self.SimEnvironment.DefineDatabase
		self.SimLib = self.SimEnvironment.SimLib
	
	def init(self, machineName):
		
		self.localMachineName = machine = self.SimEnvironment.LocalMachine
		self.localMachineEntry = self.SimEnvironment.LocalMachineEntry

		if self.localMachineEntry == None:
			dprint("Error, unknown local machine %s" % self.localMachineName)
			sys.exit(1)
		
		self.machineName = machineName
		
		if self.machineName == self.localMachineName:
			dprint("Error, remote machine %s is the same as local machine %s" % (self.machineName, self.localMachineName))
			sys.exit(1)
			
		self.machineEntry = self.ConfigurationDatabase.GetMachine(self.machineName)

		if self.machineEntry == None:
			dprint("Error, unknown remote machine %s" % self.machineName)
			sys.exit(1)
		
	
		if self.localMachineEntry.HasKey("sshsetup"):
			self.localSshSetup = self.localMachineEntry.GetKey("sshsetup")
		else:
			self.localSshSetup = ":"
		
		req_keys = ['sourcebasedir', 'user']
		self.SimLib.VerifyKeys(self.localMachineEntry, req_keys)
		
		req_keys = ['sourcebasedir', 'user', 'hostname']
		self.SimLib.VerifyKeys(self.localMachineEntry, req_keys)
	
	def GetRemoteExePath(self, locals, remotes):
		exe = self.SimEnvironment.EXECUTABLE
		
		path = self.SimLib.GetDirSuffix(locals)
		
		# if locals has a double //, trim off the first one.
		if locals.startswith(r"//"):
			locals = locals[1:]
		
		if exe[0] == "/":
			exe = exe.replace(locals, remotes)
		else:
			exe = self.SimLib.BuildPath([remotes, path, exe])

		return exe
	
	def ExecuteSameCommand(self, parrotArguments=False, stripArguments=None, sshargs=None):
		
		localSourceBaseDir = self.SimLib.GetLocalSourceBaseDir()
		sourceBaseDir = self.SimLib.GetSourceBaseDir(self.machineEntry)
		path = self.SimLib.GetDirSuffix(localSourceBaseDir)
		
		remoteExe = self.GetRemoteExePath(localSourceBaseDir, sourceBaseDir)

		if self.SimEnvironment.COMMAND != None:
			remoteExe = "%s %s" % (remoteExe, self.SimEnvironment.COMMAND)
		
		self.ExecuteCommand(remoteExe, parrotArguments, stripArguments, sshargs)
		
	def ExecuteCommand(self, command, parrotArguments=False, stripArguments=None, sshargs=None):

		cmdargs = None
		if parrotArguments == True:
			for aa in self.OptionsManager.args:
				if cmdargs == None:
					cmdargs = "%s%s%s" % (r'\\\"', aa, r'\\\"')
				else:
					cmdargs = "%s%s%s%s" % (cmdargs, r'\\\"', aa, r'\\\"')
			argStr = self.OptionsManager.BuildOptionString(stripArguments)
			
			if cmdargs != None:
				command = "%s %s %s" % (command, cmdargs, argStr)
			else:
				command = "%s %s" % (command, argStr)
				
		sshcmd = self.SimLib.GetSSHCommand(self.machineName, command, sshargs)
			
		cmd = "{ %s; } && %s" % (self.localSshSetup, sshcmd)
		#dprint("Executing Command: %s" % cmd)
		self.SimLib.ExecuteCommand(cmd)