#
# Copyright (c) 2006-2009 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: 
# makefile module
# This module is for writing calls to Function-Like Makefiles
#

import re
import os
import generic_path

class MakefileSelector(object):
	"""A "query" which is used to separate some flm interface calls
	  into separate makefile trees."""
	def __init__(self, name="default", interfacepattern=None, defaulttarget=None, ignoretargets=None):
		self.name=name
		if interfacepattern is not None:
			self.interfacepattern=re.compile(interfacepattern, re.I)
		else:
			self.interfacepattern=None
		self.defaulttarget=defaulttarget
		self.ignoretargets=ignoretargets

class Makefile(object):
	"""Representation of the file that is created from the build specification 
	   tree.
	"""
	def __init__(self, directory, selector, parent=None, filenamebase="Makefile", prologue=None, epilogue=None, defaulttargets=None):
		self.filenamebase = filenamebase
		self.directory = directory
		if selector.name != "":
			extension = "." + selector.name
		else:
			extension = ""
		self.filename = generic_path.Join(directory,filenamebase + extension)
		self.selector = selector
		self.parent = parent
		self.childlist = []
		self.file = None
		self.prologue = prologue
		self.epilogue = epilogue
		self.defaulttargets = defaulttargets
		self.dead = False

	def open(self):
		if self.dead:
			raise Exception, "Attempt to reopen completed makefile %s " % (self.filename)

		if self.file is None:
			directory = self.filename.Dir()
			if not (str(directory) == "" or directory.Exists()):
				try:
					os.makedirs(directory.GetLocalString())
				except Exception,e:
					raise Exception, "Cannot make directory '%s' for file '%s' in '%s': %s " % (str(directory),str(self.filename),str(self.directory),str(e))

			self.file = open(str(self.filename),"w+")
			
			self.file.write('# GENERATED MAKEFILE : DO NOT EDIT\n\n')
			if self.selector.defaulttarget:
				self.file.write('MAKEFILE_GROUP:=%s\n.PHONY:: %s\n%s:: # Default target\n' \
							% (self.selector.defaulttarget, self.selector.defaulttarget, self.selector.defaulttarget))
			else:
				self.file.write('MAKEFILE_GROUP:=DEFAULT\n')
			if self.prologue != None:
				self.file.write(self.prologue)
				
			if self.defaulttargets != None:
				self.file.write('# dynamic default targets\n')
				for defaulttarget in self.defaulttargets:
					self.file.write('.PHONY:: %s\n' % defaulttarget)
					self.file.write('%s:\n' % defaulttarget)
				self.file.write('\n')
			
	def addChild(self, child):
		self.open()
		self.file.write("include %s\n" % child.filename)
		child.open()

	def createChild(self, subdir):
		child = Makefile(str(self.filename.Dir().Append(subdir)), self.selector, self, self.filenamebase, self.prologue, self.epilogue, self.defaulttargets)
		self.addChild(child)
		child.open()
		return child

	def addCall(self, specname, configname, ifname, useAllInterfaces, flmpath, parameters, guard = None):
		"""Add an FLM call to the makefile.
			specname is the name of the build specification (e.g. the mmp name)
			configname is the name of the configuration which this call is made for
			flmpath is the absolute path to the flm
			parameters is an array of tuples, (paramname, paramvalue)	
			guard is a hash value that should be unique to the FLM call

		   This call will return False if the ifname does not match the selector for 
		   the makefile. e.g. it prevents one from adding a resource FLM call to a
		   makefile which is selecting export FLM calls. Selection is overridden if
		   useAllInterfaces is True.
		"""
		# create the directory if it does not exist

		if self.selector.interfacepattern is not None:
			ifmatch = self.selector.interfacepattern.search(ifname)
			if ifmatch == None and useAllInterfaces == False:
				return False

		self.open()
		# now we can write the values into the makefile
		self.file.write("# call %s\n" % flmpath)
		self.file.write("SBS_SPECIFICATION:=%s\n" % specname)
		self.file.write("SBS_CONFIGURATION:=%s\n\n" % configname)

		if guard:
			self.file.write("ifeq ($(%s),)\n%s:=1\n\n" % (guard, guard))
		
		for (p, value) in parameters:
			self.file.write("%s:=%s\n" % (p, value))
	
		self.file.write("include %s\n" % flmpath)
		self.file.write("MAKEFILE_LIST:= # work around potential gnu make stack overflow\n\n")
		
		if guard:
			self.file.write("endif\n\n")

		return True

	def addInclude(self, makefilename):
		"""
		"""
		# create the directory if it does not exist

		self.open()
		# now we can write the values into the makefile
		self.file.write("include %s\n" % (makefilename+"."+self.selector.name))

	def close(self):
		if self.file is not None:
			if self.epilogue != None:
				self.file.write(self.epilogue)
			self.file.write('# END OF GENERATED MAKEFILE : DO NOT EDIT\n')
			self.file.close()
			self.file = None
			self.dead = True

	def __del__(self):
		self.close()
			
		

class MakefileSet(object):
	grouperselector = MakefileSelector(name="")
	defaultselectors = [ 
		MakefileSelector("export", '\.export$', "EXPORT"),
		MakefileSelector("bitmap", '\.bitmap$', "BITMAP"),
		MakefileSelector("resource", '\.resource$', "RESOURCE"),
		MakefileSelector("default", '\.(?!export$|bitmap$|resource$).*$', "ALL")
		]

	def __init__(self, directory, selectors=defaultselectors, makefiles=None, parent=None, filenamebase="Makefile", prologue=None, epilogue=None, defaulttargets=None):
		self.directory = generic_path.Path(directory)
		self.filenamebase = filenamebase
		self.parent = parent
		if makefiles is not None:
			self.makefiles = makefiles
		else:
			self.makefiles = []
			for sel in selectors:
				self.makefiles.append(Makefile(directory, sel, None, filenamebase, prologue, epilogue, defaulttargets))
		self.groupermakefile = Makefile(directory, MakefileSet.grouperselector, None, filenamebase, "# GROUPER MAKEFILE\n\nALL::\n\n", "\n")
		
		for mf in self.makefiles:
			self.groupermakefile.addChild(mf)


	def createChild(self, subdir):
		"""Create a set of "sub" makefiles that are included by this set."""
		newmakefiles = []
		for mf in self.makefiles:
			newmf = mf.createChild(subdir)
			newmakefiles.append(newmf)

		newset = MakefileSet(str(self.directory.Append(subdir)), None, newmakefiles, self, self.filenamebase)
		self.groupermakefile.addChild(newset.groupermakefile)

		return newset

	def addCall(self, specname, configname, ifname, useAllInterfaces, flmpath, parameters, guard = None):
		"""Find out which makefiles to write this FLM call to 
		   and write it to those (e.g. the exports makefile) """
		for f in self.makefiles:
			f.addCall(specname, configname, ifname, useAllInterfaces, flmpath, parameters, guard)

	def addInclude(self, makefilename):
		"""include a makefile from each of the makefiles in the set - has the selector name appended to it."""
		for f in self.makefiles:
			f.addInclude(makefilename)

	def makefileNames(self):
		for mf in self.makefiles:
			yield str(mf.filename)
	
	def ignoreTargets(self, makefile):
		"""Get hold of a makefile's selector based on its name and
		   determine whether it ignores targets based on a regexp."""
		for mf in self.makefiles:
			filename = str(mf.filename)			
			if filename == makefile:
				return mf.selector.ignoretargets 
		return None

	def close(self):
		for mf in self.makefiles:
			mf.close()
		self.groupermakefile.close()

	def __del__(self):
		self.close()