#
# Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of the License "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description: 
#
# raptor_api module
#
# Python API for Raptor. External code should interact with Raptor via this
# module only, as it is the only programatic interface considered public. The
# command line --query option is also implemented using this module.

# constants
ALL = 1

# objects

class Reply(object):
	"""object to return values from API calls.
	"""
	def __init__(self, text="", raptor=None):
		self._raptor = raptor
		self.text = text
		
	def _getEvaluator(self, meaning):
		""" Note: Will pass on Evaluator constructor exceptions """
		try:
			return self.__evaluator
		except AttributeError:	
			# create an evaluator for the named configuration
			tmp = raptor_data.Alias("tmp")
			tmp.SetProperty("meaning", meaning)
		
			units = tmp.GenerateBuildUnits(self._raptor.cache)
			self.__evaluator = self._raptor.GetEvaluator(None, units[0])
			return self.__evaluator
	
	def __str__(self):
		name = type(self).__name__.lower()
		
		string = "<" + name
		children = []
		longend = False
		
		for attribute,value in self.__dict__.items():
			if attribute != "text" and not attribute.startswith('_'):
				if isinstance(value, Reply):
					children.append(value)
				elif isinstance(value, list):
					for item in value:
						if isinstance(item, Reply):
							children.append(item)
						else:
							raise BadReply(str(item)+" is not a Reply object")
				else:
					if value != None: # skip attributes whose value is None
						string += " %s='%s'" % (attribute, value)
		
		if children or self.text:
			string += ">"
			longend = True
		
		if self.text:
			string += self.text
			children.sort()
			# Note mixing sortable and unsortable lists results in
			# sort not working, so if you really need your
			# children to come out in the right order, put them in
			# a list.  This is only for niceness, where it works.
		
		if children:
			string += "\n"
				
			for c in children:
				clines = str(c).rstrip().split("\n")
				string += "".join(map(lambda l:"  "+l+"\n",clines))
			
		if longend:
			string += "</%s>\n" % name
		else:	
			string += "/>\n"
		
		return string

	
class BadReply(Exception):
	pass

class Alias(Reply):
	def __init__(self, name, meaning):
		super(Alias,self).__init__()
		self.name = name
		self.meaning = meaning
	
	def __cmp__(self, other):
		""" Add __cmp__ to enable comparisons between two Alias objects based upon name."""
		return cmp(self.name, other.name)

class Config(Reply):
	def __init__(self, raptor, name, text = None):
		""" Constructor to create a Config from a user-supplied name.
		possibly including aliases (but not groups)
		"""
		super(Config,self).__init__(text, raptor)

		self.query = name
		
		# Work out the real name
		names = name.split(".")
		if names[0] in self._raptor.cache.aliases:
			x = self._raptor.cache.FindNamedAlias(names[0])
			
			if len(names) > 1:
				self.meaning = x.meaning + "." + ".".join(names[1:])
			else:
				self.meaning = x.meaning
				
		elif names[0] in self._raptor.cache.variants:
			self.meaning = name
			
		else:
			raise BadQuery("'%s' is not an alias or a variant" % names[0])
		
	def resolveOutputPath(self):
		""" Get the outputpath """
		try:
			evaluator = self._getEvaluator(self.meaning)
			# This is messy as some configs construct the path inside the FLM
			# rather than talking it from the XML: usually because of some
			# conditional logic... but maybe some refactoring could avoid that.
			releasepath = evaluator.Get("RELEASEPATH")
			if not releasepath:
				raise BadQuery("could not get RELEASEPATH for config '%s'" % self.fullname)
		
			variantplatform = evaluator.Get("VARIANTPLATFORM")
			varianttype = evaluator.Get("VARIANTTYPE")
			featurevariantname = evaluator.Get("FEATUREVARIANTNAME")
		
			platform = evaluator.Get("TRADITIONAL_PLATFORM")
		
			if platform == "TOOLS2":
				self.outputpath = releasepath
			else:
				if not variantplatform:
					raise BadQuery("could not get VARIANTPLATFORM for config '%s'" % self.fullname)
			
				if featurevariantname:
					variantplatform += featurevariantname
				
				if not varianttype:
					raise BadQuery("could not get VARIANTTYPE for config '%s'" % self.fullname)
			
				self.outputpath = str(generic_path.Join(releasepath, variantplatform, varianttype))
		except Exception, e: # Unable to determine output path
			self.text = str(e)

	def resolveMetadata(self):
		try:
			metadata = self.metadata
		except AttributeError:
			metadata = MetaData(self.meaning, self._raptor)
			self.metadata = metadata
			
		try:
			metadata.resolve()
		except Exception:
			# Evaluator exception hopefully - already handled
			self.metadata = None

	def resolveBuild(self):
		try:
			build = self.build
		except AttributeError:
			build = Build(self.meaning, self._raptor)
			self.build = build
			
		try:
			build.resolve()
		except Exception:
			# Evaluator exception, hopefully - already handled
			self.build = None
	
	def resolveTargettypes(self):
		try:
			build = self.build
		except AttributeError:	
			build = Build(self.meaning, self._raptor)
			self.build = build
		
		try:
			build.resolveTargettypes()
		except Exception:
			# Evaluator exception hopefully - already handled
			self.build = None

class MetaData(Reply):
	def __init__(self, meaning, raptor):
		super(MetaData,self).__init__("", raptor)
		self.__meaning = meaning

	def resolve(self):
		includepaths = []
		preincludeheader = ""
		platmacros = []

		evaluator = self._getEvaluator(self.__meaning)

		# Initialise data and metadata objects
		buildunits = raptor_data.GetBuildUnits([self.__meaning], self._raptor.cache, self._raptor)
		metareader = raptor_meta.MetaReader(self._raptor, buildunits)
		metadatafile = raptor_meta.MetaDataFile(generic_path.Path("bld.inf"), "cpp", [], None, self._raptor)
		
		# There is only one build platform here; obtain the pre-processing include paths,
		# OS pre-include file, compiler pre-include file and macros.			
		includepaths = metadatafile.preparePreProcessorIncludePaths(metareader.BuildPlatforms[0])
		preincludeheader = metareader.BuildPlatforms[0]['VARIANT_HRH']
		
		# Macros arrive as a a list of strings, or a single string, containing definitions of the form "name" or "name=value". 
		platmacrolist = metadatafile.preparePreProcessorMacros(metareader.BuildPlatforms[0])
		platmacros.extend(map(lambda macrodef: [macrodef.partition("=")[0], macrodef.partition("=")[2]], platmacrolist))

		# Add child elements to appropriate areas if they were calculated
		if len(includepaths) > 0:
			self.includepaths = map(lambda x: Include(str(x)), includepaths)
		
		if preincludeheader != "":
			self.preincludeheader = PreInclude(str(preincludeheader))
		
		if len(platmacros):
			self.platmacros = map(lambda x: Macro(x[0],x[1]) if x[1] else Macro(x[0]), platmacros)

class Build(Reply):
	def __init__(self, meaning, raptor):
		super(Build,self).__init__("", raptor)
		self.__meaning = meaning
		
	def resolve(self):
		compilerpreincludeheader = ""
		sourcemacros = []

		evaluator = self._getEvaluator(self.__meaning)

		platform = evaluator.Get("TRADITIONAL_PLATFORM")
			
		# Compiler preinclude files may or may not be present, depending on the configuration.
		if evaluator.Get("PREINCLUDE"):
			compilerpreincludeheader = generic_path.Path(evaluator.Get("PREINCLUDE"))
			
		# Macros arrive as a a list of strings, or a single string, containing definitions of the form "name" or "name=value". 
		# If required, we split to a list, and then processes the constituent parts of the macro.
		sourcemacrolist = evaluator.Get("CDEFS").split()
		sourcemacros.extend(map(lambda macrodef: [macrodef.partition("=")[0], macrodef.partition("=")[2]], sourcemacrolist))

		if platform == "TOOLS2":
			# Source macros are determined in the FLM for tools2 builds, therefore we have to
			# mimic the logic here
			if 'win' in raptor.hostplatform or 'win32' in self.__meaning:
				sourcemacrolist = evaluator.Get("CDEFS.WIN32").split()
			else:
				sourcemacrolist = evaluator.Get("CDEFS.LINUX").split()
			sourcemacros.extend(map(lambda macrodef: [macrodef.partition("=")[0], macrodef.partition("=")[2]], sourcemacrolist))

		if len(sourcemacros):
			self.sourcemacros = map(lambda x: Macro(x[0],x[1]) if x[1] else Macro(x[0]), sourcemacros)
			
		if compilerpreincludeheader:
			self.compilerpreincludeheader = PreInclude(str(compilerpreincludeheader))

	def resolveTargettypes(self):
		evaluator = self._getEvaluator(self.__meaning)
		targettypes = evaluator.Get("TARGET_TYPES").split(' ')
		self.targettypes = []
		for type in targettypes:
			self.targettypes.append(TargetType(type))
		self.targettypes.sort()	

class TargetType(Reply):
	def __init__(self, name):
		super(TargetType,self).__init__()
		self.name = name

	def __cmp__(self, other):
		return cmp(self.name, other.name)

class Product(Reply):
	def __init__(self, name):
		super(Product,self).__init__()
		self.name = name
	
	def __cmp__(self, other):
		""" Add __cmp__ to enable comparisons between two Product objects based upon name."""
		return cmp(self.name, other.name)

class Include(Reply):
	def __init__(self, path):
		super(Include,self).__init__()
		self.path = path

class PreInclude(Reply):
	def __init__(self, file):
		super(PreInclude,self).__init__()
		self.file = file

class Macro(Reply):
	def __init__(self, name, value=None):
		super(Macro,self).__init__()
		self.name = name
		self.value = value

import generic_path
import raptor
import raptor_data
import raptor_meta
import re

class Context(object):
	"""object to contain state information for API calls.
	
	For example,
	
	api = raptor_api.Context()
	val = api.getaliases("X")
	"""
	def __init__(self, initialiser=None):
		# this object has a private Raptor object that can either be
		# passed in or created internally.
		
		if initialiser == None:
			self.__raptor = raptor.Raptor()
		else:
			self.__raptor = initialiser
			
	def stringquery(self, query):
		"""turn a string into an API call and execute it.
		
		This is a convenience method for "lazy" callers.
		
		The return value is also converted into a well-formed XML string.
		"""
		
		if query == "aliases":
			aliases = self.getaliases()
			return "".join(map(str, aliases)).strip()
		
		elif query == "products":
			variants = self.getproducts()
			return "".join(map(str, variants)).strip()
		
		elif query.startswith("config"):
			match = re.match("config\[(.*)\]", query)
			if match:
				config = self.getconfig(match.group(1))
				return str(config).strip()
			else:
				raise BadQuery("syntax error")
		
		raise BadQuery("unknown query")

	def getaliases(self, type=""):
		"""extract all aliases of a given type.
		
		the default type is "".
		to get all aliases pass type=ALL
		"""
		aliases = []
		
		for a in self.__raptor.cache.aliases.values():
			if type == ALL or a.type == type:
				# copy the members we want to expose
				aliases.append( Alias(a.name, a.meaning) )
		aliases.sort()	
		return aliases
	
	def getconfig(self, name):
		"""extract the values for a given configuration.
		
		'name' should be an alias or variant followed optionally by a
		dot-separated list of variants. For example "armv5_urel" or
		"armv5_urel.savespace.vasco".
		"""

		config = Config(self.__raptor, name)
		config.resolveOutputPath()
		config.resolveTargettypes()
		config.resolveMetadata()
		config.resolveBuild()
		return config		
		
	def getproducts(self):
		"""extract all product variants."""
		
		variants = []
		
		for v in self.__raptor.cache.variants.values():
			if v.type == "product":
				# copy the members we want to expose
				variants.append( Product(v.name) )
		variants.sort()	
		return variants
	
class BadQuery(Exception):
	pass

# end of the raptor_api module