# 
# MDB -- MachineDatabase wrapper around pyini.
# Convienient access to the machine database.
# 
# Michael Thomas <mthomas@cct.lsu.edu>
# Center for Computation & Technology
# Louisiana State University 
# 
#

import pyini
import os
import sys

class Entry:
	def __init__(self, name, dict):
		keys = dict.keys()
		
		self.InternalDictionary = dict
		self.EntryName = name
		
		for key in keys:
			io = dict[key]
			setattr(self, key, io.Value)
	
	def GetKeys(self):
		return self.InternalDictionary.keys()
	
	def HasKey(self, key):
		return hasattr(self, key)
	
	# can also just be accessed as MachineEntry.attribute
	def GetKey(self, key):
		if self.HasKey(key):
			return getattr(self, key)

	def HasKeys(self, keys):
		for k in keys:
			if not(self.HasKey(k)):
				return False
		
		return True
		
class ConfigurationDatabase:

	def __init__(self, env, mdb=None, cdb=None, udb=None):
		self.mdbFilename = mdb
		self.cdbFilename = cdb
		self.udbFilename = udb
		self.simEnv = env
		
		self.SyntaxFile = "%s%s%s" % (self.simEnv.SYNTAX_PATH, os.sep, "mdb-syntax.ini")
		self.DescriptionSyntaxFile = "%s%s%s" % (self.simEnv.SYNTAX_PATH, os.sep, "description-syntax.ini")
		self.MachineParser = None
		self.ConfigParser = None
		self.syntaxChecker = None
		self.MachineCache = dict()
		self.ConfigCache = dict()
		
	def Load(self, mdb=None, cdb=None, udb=None):
		if mdb == None and self.mdbFilename == None:
			print "Error initializing machine database: No database file provided"
			sys.exit(1)
		
		if cdb == None and self.cdbFilename == None:
			print "Error initializing configuration database: No database file provided"
			sys.exit(1)
		
		self.CheckSyntax()
		
		# if we made it here, our syntax has passed and self.parser will be available.
		
	def CheckSyntax(self):
		
		# first, verify the correctness of our mdb syntax file.
		sc = pyini.IniSyntaxChecker(self.DescriptionSyntaxFile, self.SyntaxFile);
		sc.SyntaxCheck()
		
		# now verify the correctness of our passed in mdb database
		self.syntaxChecker = pyini.IniSyntaxChecker(self.SyntaxFile, self.mdbFilename, True)
		self.syntaxChecker.SyntaxCheck()
		
		# borrow the loaded iniParser so we don't have to parse 
		# the mdb database again. It's kind of large!
		self.MachineParser = self.syntaxChecker.IniParser
		
		# load the cdb database, which at the moment has no syntax file and convert any blocks to lists
		self.ConfigParser = pyini.IniParser(self.cdbFilename)
		self.ConvertBlocks()
		
		if self.udbFilename != None:
			# import new sections to the machine database, but not the config database.
			self.MachineParser.UpdateFromIni(self.udbFilename, True)
			self.ConfigParser.UpdateFromIni(self.udbFilename)
	
	
	def ConvertBlocks(self):
		keys = self.ConfigParser.GetGlobalKeys()
		
		for k in keys:
			io = self.ConfigParser.GetGlobalOption(k)
			if io.IsBlock:
				io.ConvertToList()

	# --- ACCESSOR METHODS ---
	
	def GetMachine(self, key):
		type = "Machine"
		
		cache = getattr(self, "%sCache" % type)
		parser = getattr(self, "%sParser" % type)
		
		if cache.has_key(key):
			return cache[key]
		
		if parser.HasSection(key):
			sdict = parser.GetSectionAsDict(key)
			entry = Entry(key, sdict)
			cache[key] = entry
			return entry
		else:
			print "Error retreiving %s entry for %s %s: %s %s doesn't exist" % (type, type, key, type, key)
			sys.exit(1)
	
	def HasMachineEntry(self, key):
		type = "Machine"
		cache = getattr(self, "%sCache" % type)
		parser = getattr(self, "%sParser" % type)
		
		if cache.has_key(key):
			return True
		
		return parser.HasSection(key)

	def GetMachines(self):
		type = "Machine"
		parser = getattr(self, "%sParser" % type)
		return parser.GetSections()
		
	def GetConfigOption(self, option):
		return self.ConfigParser.GetGlobalOption(option).Value
		
	def HasConfigOption(self, option):
		return self.ConfigParser.HasOption(None, option)

	def GetConfigOptions(self):
		return self.ConfigParser.GetGlobalKeys()