import ompdModule
import imp

class ompd_parallel(object):
	
	def __init__(self, parallel_handle):
		""" Initializes an ompd_parallel object with the pointer
		to a handle of a parallel region."""
		self.parallel_handle = parallel_handle
		self.threads = {}
		self.itasks = {}
		self.enclosing_parallel_handle = None
		self.enclosing_parallel = False
		self.task_handle = None
	
	def get_thread_in_parallel(self, thread_num):
		"""Obtains thread handles for the threads associated with the
		parallel region specified by parallel_handle."""
		if not thread_num in self.threads:
			thread_handle = ompdModule.call_ompd_get_thread_in_parallel(self.parallel_handle, thread_num)
			self.threads[thread_num] = ompd_thread(thread_handle)
		return self.threads[thread_num]
	
	def get_enclosing_parallel_handle(self):
		"""Obtains a parallel handle for the parallel region enclosing
		the parallel region specified by parallel_handle."""
		if not self.enclosing_parallel_handle:
			self.enclosing_parallel_handle = ompdModule.call_ompd_get_enclosing_parallel_handle(self.parallel_handle)
		return self.enclosing_parallel_handle
	
	def get_enclosing_parallel(self):
		if not self.enclosing_parallel:
			self.enclosing_parallel = ompd_parallel(self.get_enclosing_parallel_handle())
		return self.enclosing_parallel
	
	def get_task_in_parallel(self, thread_num):
		"""Obtains handles for the implicit tasks associated with the
		parallel region specified by parallel_handle."""
		if not thread_num in self.itasks:
			task_handle = ompdModule.call_ompd_get_task_in_parallel(self.parallel_handle, thread_num)
			self.itasks[thread_num] = ompd_task(task_handle)
		return self.itasks[thread_num]
	
	def __del__(self):
		"""Releases the parallel handle."""
		pass # let capsule destructors do the job

class ompd_task(object):
	
	def __init__(self, task_handle):
		"""Initializes a new ompd_task_handle object and sets the attribute
		to the task handle specified."""
		self.task_handle = task_handle
		self.task_parallel_handle = False
		self.generating_task_handle = False
		self.scheduling_task_handle = False
		self.task_parallel = False
		self.generating_task = False
		self.scheduling_task = False
		self.task_frames = None
		self.task_frame_flags = None
	
	def get_task_parallel_handle(self):
		"""Obtains a task parallel handle for the parallel region enclosing
		the task region specified."""
		if not self.task_parallel_handle:
			self.task_parallel_handle = ompdModule.call_ompd_get_task_parallel_handle(self.task_handle)
		return self.task_parallel_handle
	
	def get_task_parallel(self):
		if not self.task_parallel:
			self.task_parallel = ompd_parallel(self.get_task_parallel_handle())
		return self.task_parallel
	
	def get_generating_task_handle(self):
		"""Obtains the task handle for the task that created the task specified
		by the task handle."""
		if not self.generating_task_handle:
			self.generating_task_handle = ompdModule.call_ompd_get_generating_task_handle(self.task_handle)
		return self.generating_task_handle
	
	def get_generating_task(self):
		if not self.generating_task:
			self.generating_task = ompd_task(ompdModule.call_ompd_get_generating_task_handle(self.task_handle))
		return self.generating_task
	
	def get_scheduling_task_handle(self):
		"""Obtains the task handle for the task that scheduled the task specified."""
		if not self.scheduling_task_handle:
			self.scheduling_task_handle = ompdModule.call_ompd_get_scheduling_task_handle(self.task_handle)
		return self.scheduling_task_handle
	
	def get_scheduling_task(self):
		"""Returns ompd_task object for the task that scheduled the current task."""
		if not self.scheduling_task:
			self.scheduling_task = ompd_task(self.get_scheduling_task_handle())
		return self.scheduling_task

	def get_task_function(self):
		"""Returns long with address of function entry point."""
		return ompdModule.call_ompd_get_task_function(self.task_handle)
	
	def get_task_frame_with_flags(self):
		"""Returns enter frame address and flag, exit frame address and flag for current task handle."""
		if self.task_frames is None or self.task_frame_flags is None:
			ret_value = ompdModule.call_ompd_get_task_frame(self.task_handle)
			if isinstance(ret_value, tuple):
				self.task_frames = (ret_value[0], ret_value[2])
				self.task_frame_flags = (ret_value[1], ret_value[3])
			else:
				return ret_value
		return (self.task_frames[0], self.task_frame_flags[0], self.task_frames[1], self.task_frame_flags[1])
	
	def get_task_frame(self):
		"""Returns enter and exit frame address for current task handle."""
		if self.task_frames is None:
			ret_value = ompdModule.call_ompd_get_task_frame(self.task_handle)
			if isinstance(ret_value, tuple):
				self.task_frames = (ret_value[0], ret_value[2])
			else:
				return ret_value
		return self.task_frames
	
	def __del__(self):
		"""Releases the task handle."""
		pass # let capsule destructors do the job


class ompd_thread(object):
	
	def __init__(self, thread_handle):
		"""Initializes an ompd_thread with the data received from
		GDB."""
		self.thread_handle = thread_handle
		self.parallel_handle = None
		self.task_handle = None
		self.current_task = False
		self.current_parallel = False
		self.thread_id = False
	
	def get_current_parallel_handle(self):
		"""Obtains the parallel handle for the parallel region associated with
		the given thread handle."""
		#TODO: invalidate thread objects based on `gdb.event.cont`. This should invalidate all internal state.
		self.parallel_handle = ompdModule.call_ompd_get_curr_parallel_handle(self.thread_handle)
		return self.parallel_handle
	
	def get_current_parallel(self):
		"""Returns parallel object for parallel handle of the parallel region 
		associated with the current thread handle."""
		if not self.current_parallel:
			self.current_parallel = ompd_parallel(self.get_current_parallel_handle())
		return self.current_parallel
		
	def get_current_task_handle(self):
		"""Obtains the task handle for the current task region of the
		given thread."""
		return ompdModule.call_ompd_get_curr_task_handle(self.thread_handle)

	def get_thread_id(self):
		"""Obtains the ID for the given thread."""
		if not self.thread_id:
			self.thread_id = ompdModule.call_ompd_get_thread_id(self.thread_handle)
		return self.thread_id

	def get_current_task(self):
		"""Returns task object for task handle of the current task region."""
		return ompd_task(self.get_current_task_handle())
	
	def get_state(self):
		"""Returns tuple with OMPD state (long) and wait_id, in case the thread is in a 
		waiting state. Helper function for 'ompd threads' command."""
		(state, wait_id) = ompdModule.call_ompd_get_state(self.thread_handle)
		return (state, wait_id)
	
	def __del__(self):
		"""Releases the given thread handle."""
		pass # let capsule destructors do the job