#

# Copyright (c) 2006-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_data module

# This module contains the classes that make up the Raptor Data Model.

#

import copy

import generic_path

import os

import hashlib

import raptor_utilities

import re

import types

import sys

import subprocess

from tempfile import gettempdir

from time import time, clock

import traceback

import raptor_cache

class MissingInterfaceError(Exception):

	def __init__(self, s):

		Exception.__init__(self,s)

# What host platforms we recognise

# This allows us to tie some variants to one host platform and some to another

class HostPlatform(object):

	""" List the host platforms on which we can build.  Allow configuration

 	    files to specify different information based on that.

	"""

	hostplatforms = ["win32", "win64", "linux2"]

	hostplatform = sys.platform

	@classmethod

	def IsKnown(cls, platformpattern):

		"Does the parameter match the name of a known platform "

		hpnre = re.compile(platformpattern, re.I)

		for hp in cls.hostplatforms:

			if hpnre.match(hp):

				return True

		return False

	@classmethod

	def IsHost(cls, platformpattern):

		""" Does the parameter match the name of the

		    platform that we're executing on? """

		ppre = re.compile(platformpattern, re.I)

		if ppre.match(cls.hostplatform):

			return True

		return False

# Make sure not to start up on an unsupported platform

if not HostPlatform.IsKnown(HostPlatform.hostplatform):

	raise Exception("raptor_data module loaded on an unrecognised platform '%s'. Expected one of %s" % (hostplatform, str(hostplatforms)))

# raptor_data module classes

class Model(object):

	"Base class for data-model objects"

	__slots__ = ('host', 'source', 'cacheID')

	def __init__(self):

		self.source = None	# XML file

		self.host = None

		self.cacheID = ""	# default set of cached objects

		# not using the cache parameter - there to make the 

		# init for all Model objects "standard"

	def SetSourceFile(self, filename):

		self.source = filename

	def SetProperty(self, name, value):

		raise InvalidPropertyError()

	def AddChild(self, child):

		raise InvalidChildError()

	def Valid(self):

		return False

	def IsApplicable(self):

		"This variant may be caused to only apply when used on a particular host build platform"

		if self.host is None:

			return True

		if HostPlatform.IsHost(self.host):

			return True

		return False

class InvalidPropertyError(Exception):

	pass

class InvalidChildError(Exception):

	pass

class BadReferenceError(Exception):

	pass

class Reference(Model):

	"Base class for data-model reference objects"

	def __init__(self, ref = None):

		Model.__init__(self)

		self.ref = ref

		self.modifiers = []

	def SetProperty(self, name, value):

		if name == "ref":

			self.ref = value

		elif name == "mod":

			self.modifiers = value.split(".")

		else:

			raise InvalidPropertyError()

	def Resolve(self):

		raise BadReferenceError()

	def GetModifiers(self, cache):

		return [ cache.FindNamedVariant(m) for m in self.modifiers ]

	def Valid(self):

		return self.ref

class VariantContainer(Model):

	def __init__(self):

		Model.__init__(self)	# base class constructor

		self.variants = []

	def __str__(self):

		return "\n".join([str(v) for v in self.variants])

	def AddVariant(self, variant):

		if type(variant) is types.StringTypes:

			variant = VariantRef(ref = variant)

		# Only add the variant if it's not in the list

		# already

		if not variant in self.variants:

			self.variants.append(variant)

	def GetVariants(self, cache):

		# resolve any VariantRef objects into Variant objects

		missing_variants = []

		for i,var in enumerate(self.variants):

			if isinstance(var, Reference):

				try:

					self.variants[i] = var.Resolve(cache=cache)

				except BadReferenceError:

					missing_variants.append(var.ref)

		if len(missing_variants) > 0:

			raise MissingVariantException("Missing variants '%s'", " ".join(missing_variants))

		return self.variants

class Interface(Model):

	def __init__(self, name = None):

		Model.__init__(self)	# base class constructor

		self.name = name

		self.flm = None

		self.abstract = False

		self.extends = None

		self.params = []

		self.paramgroups = []

	def __str__(self):

		return "<interface name='%s'>" % self.name + "</interface>"

	def FindParent(self, cache):

		try:

			return cache.FindNamedInterface(self.extends, self.cacheID)

		except KeyError:

			raise BadReferenceError("Cannot extend interface because it cannot be found: "+str(self.extends))

	def GetParams(self, cache):

		if self.extends != None:

			parent = self.FindParent(cache)

			# what parameter names do we have already?

			names = set([x.name for x in self.params])

			# pick up ones we don't have that are in our parent

			pp = []

			for p in parent.GetParams(cache):

				if not p.name in names:

					pp.append(p)

			# list parent parameters first then ours

			pp.extend(self.params)

			return pp

		return self.params

	def GetParamGroups(self, cache):

		if self.extends != None:

			parent = self.FindParent(cache)

			# what parameter names do we have already?

			patterns = set([x.pattern for x in self.paramgroups])

			# pick up ones we don't have that are in our parent

			for g in parent.GetParamGroups(cache):

				if not g.pattern in patterns:

					self.paramgroups.append(g)

		return self.paramgroups

	def GetFLMIncludePath(self, cache):

		"absolute path to the FLM"

		if self.flm == None:

			if self.extends != None:

				parent = self.FindParent(cache)

				return parent.GetFLMIncludePath(cache)

			else:

				raise InvalidPropertyError()

		if not os.path.isabs(self.flm):

			self.flm = os.path.join(os.path.dirname(self.source), self.flm)

		return generic_path.Path(self.flm)

	def SetProperty(self, name, value):

		if name == "name":

			self.name = value

		elif name == "flm":

			self.flm = value

		elif name == "abstract":

			self.abstract = (value == "true")

		elif name == "extends":

			self.extends = value

		else:

			raise InvalidPropertyError()

	def AddChild(self, child):

		if isinstance(child, Parameter):

			self.AddParameter(child)

		elif isinstance(child, ParameterGroup):

			self.AddParameterGroup(child)

		else:

			raise InvalidChildError()

	def AddParameter(self, parameter):

		self.params.append(parameter)

	def AddParameterGroup(self, parametergroup):

		self.paramgroups.append(parametergroup)

	def Valid(self):

		return (self.name != None)

class InterfaceRef(Reference):

	def __str__(self):

		return "<interfaceRef ref='%s'/>" % self.ref

	def Resolve(self, cache):

		try:

			return cache.FindNamedInterface(self.ref, self.cacheID)

		except KeyError:

			raise BadReferenceError()

class Specification(VariantContainer):

	def __init__(self, name = "", type = ""):

		VariantContainer.__init__(self)	# base class constructor

		self.name = name

		self.type = type

		self.interface = None

		self.childSpecs = []

		self.parentSpec = None

	def __str__(self):

		s = "<spec name='%s'>" % str(self.name)

		s += VariantContainer.__str__(self)

		for c in self.childSpecs:

			s += str(c) + '\n'

		s += "</spec>"

		return s

	def SetProperty(self, name, value):

		if name == "name":

			self.name = value

		else:

			raise InvalidPropertyError()

	def Configure(self, config, cache):

		# configure all the children (some may be Filters or parents of)

		for spec in self.GetChildSpecs():

			spec.Configure(config, cache = cache)

	def HasInterface(self):

		return self.interface != None

	def SetInterface(self, interface):

		if isinstance(interface, Interface) \

		or isinstance(interface, InterfaceRef):

			self.interface = interface

		else:

			self.interface = InterfaceRef(ref = interface)

	def GetInterface(self, cache):

		"""return the Interface (fetching from the cache if it was a ref)

		may return None"""

		if self.interface == None \

		or isinstance(self.interface, Interface):

			return self.interface

		if isinstance(self.interface, InterfaceRef):

			try:

				self.interface = self.interface.Resolve(cache=cache)

				return self.interface

			except BadReferenceError:

				raise MissingInterfaceError("Missing interface %s" % self.interface.ref)

	def AddChild(self, child):

		if isinstance(child, Specification):

			self.AddChildSpecification(child)

		elif isinstance(child, Interface) \

		  or isinstance(child, InterfaceRef):

			self.SetInterface(child)

		elif isinstance(child, Variant) \

		  or isinstance(child, VariantRef):

			self.AddVariant(child)

		else:

			raise InvalidChildError()

	def AddChildSpecification(self, child):

		child.SetParentSpec(self)

		self.childSpecs.append(child)

	def SetParentSpec(self, parent):

		self.parentSpec = parent

	def GetChildSpecs(self):

		return self.childSpecs

	def Valid(self):

		return True

	def GetAllVariantsRecursively(self, cache):

		"""Returns all variants contained in this node and in its ancestors.

		The returned value is a list, the structure of which is [variants-in-parent,

		variants-in-self].

		Note that the function recurses through parent *Specifications*, not through

		the variants themselves.

		"""

		if self.parentSpec:

			variants = self.parentSpec.GetAllVariantsRecursively(cache = cache)

		else:

			variants = []

		variants.extend( self.GetVariants(cache = cache) )

		return variants

class Filter(Specification):

	"""A Filter is two Specification nodes and a True/False switch.

	Filter extends Specification to have two nodes, only one of

	which can be active at any time. Which node is active is determined

	when the Configure method is called after setting up a Condition.

	If several Conditions are set, the test is an OR of all of them."""

	def __init__(self, name = ""):

		Specification.__init__(self, name = name)	# base class constructor

		self.Else = Specification(name = name)     # same for Else part

		self.isTrue = True

		self.configNames = set()            #

		self.variableNames = set()          # TO DO: Condition class

		self.variableValues = {}            #

	def __str__(self, prefix = ""):

		s = "<filter name='%s'>\n"% self.name

		s += "<if config='%s'>\n" % " | ".join(self.configNames)

		s += Specification.__str__(self)

		s += "</if>\n <else>\n"

		s += str(self.Else)

		s += " </else>\n</filter>\n"

		return s

	def SetConfigCondition(self, configName):

		self.configNames = set([configName])

	def AddConfigCondition(self, configName):

		self.configNames.add(configName)

	def SetVariableCondition(self, variableName, variableValues):

		self.variableNames = set([variableName])

		if type(variableValues) == types.ListType:

			self.variableValues[variableName] = set(variableValues)

		else:

			self.variableValues[variableName] = set([variableValues])

	def AddVariableCondition(self, variableName, variableValues):

		self.variableNames.add(variableName)

		if type(variableValues) == types.ListType:

			self.variableValues[variableName] = set(variableValues)

		else:

			self.variableValues[variableName] = set([variableValues])

	def Configure(self, buildUnit, cache):

		self.isTrue = False

		if buildUnit.name in self.configNames:

			self.isTrue = True

		elif self.variableNames:

			evaluator = Evaluator(self.parentSpec, buildUnit, cache=cache)

			for variableName in self.variableNames:

				variableValue = evaluator.Get(variableName)

				if variableValue in self.variableValues[variableName]:

					self.isTrue = True

					break

		# configure all the children too

		for spec in self.GetChildSpecs():

			spec.Configure(buildUnit, cache=cache)

	def HasInterface(self):

		if self.isTrue:

			return Specification.HasInterface(self)

		else:

			return self.Else.HasInterface()

	def GetInterface(self, cache):

		if self.isTrue:

			return Specification.GetInterface(self, cache = cache)