from ModelObject import ModelObject
from Model import Model, ModelError
from Klass import Klass
from Attr import Attr
from MiscUtils import NoDefault
from MiscUtils.DataTable import DataTable
from MiscUtils.DictForArgs import *
from UserDict import UserDict

try: # for Python < 2.3
    True, False
except NameError:
    True, False = 1, 0


class Klasses(ModelObject, UserDict):
    """A Klasses object can read a list of class specifications in a spreadsheet (.csv).

    Note that Klasses inherits UserDict, allowing you to access class specifications by name.

    """


    ## Init ##

    def __init__(self, model):
        UserDict.__init__(self)
        assert isinstance(model, Model)
        self._model         = model
        self._klasses       = []
        self._filename      = None
        self._name          = None
        self._tableHeadings = None
        self.initTypeMap()

    def classNames(self):
        return ['ModelObject', 'Klasses', 'Klass', 'Attr', 'BasicTypeAttr', 'ObjRefAttr', 'EnumAttr', 'DateTimeAttr']

    def initTypeMap(self):
        """Initialize the type map.

        Initializes self._typeNamesToAttrClassNames which maps MiddleKit type
        names (like int and enum) to the name of the attribute class that would
        implement them. Mapping to class names rather than actual classes is key,
        because in __init__, a different set of attribute classes can be passed in.

        """
        map = {}
        names = 'bool int long float string enum date time list ObjRef decimal'
        names = names.split()
        for name in names:
            map[name] = name.capitalize()+'Attr'
        map['datetime'] = 'DateTimeAttr'
        self._typeNamesToAttrClassNames = map

    def assignClassIds(self, generator):
        if self.setting('UseHashForClassIds', False):
            # This is better because class ids will likely stay the same even as
            # you change your MiddleKit model. For example, class ids across
            # different sandboxes of your application (development, test and
            # production) would match up even as you add and remove classes.
            # However, renaming classes changes the id!
            from sets import Set # needs Python >= 2.3
            allIds = Set()
            for klass in self._model._allKlassesInOrder:
                klass.setId(allIds)
        else:
            id = 1
            for klass in self._model._allKlassesInOrder:
                klass.setId(id)
                id += 1


    ## Accessing ##

    def model(self):
        return self._model

    def filename(self):
        return self._filename

    def klassesInOrder(self):
        """Return a list of all the Klasses in the order they were declared.

        Do not modify the list.

        """
        return self._klasses


    ## Reading files ##

    def read(self, filename):
        # @@ 2000-11-24 ce: split into readTable()
        self._filename = filename
        table = DataTable(filename, usePickleCache=0)  # because PickleCache is used at the Model level

        # in case we want to look at these later:
        self._tableHeadings = table.headings()

        try:
            line = 2
            for row in table:
                row = ExpandDictWithExtras(row, dictForArgs=PyDictForArgs)
                for key in ['Class', 'Attribute']:
                    if not row.has_key(key):
                        print 'ERROR'
                        print 'Required key %s not found in row:' % key
                        print 'row:', row
                        print 'keys:', row.keys()
                        print row[key]  # throws exception
                if row['Class']:
                    pyClass = self._model.coreClass('Klass')
                    klass = pyClass(self, row)
                    self.addKlass(klass)
                else:
                    name = row['Attribute']
                    if name and name[0] != '#' and name[-1] != ':':
                        pyClassName = self.pyClassNameForAttrDict(row)
                        pyClass = self._model.coreClass(pyClassName)
                        klass.addAttr(pyClass(row))
                line += 1
        except ModelError, e:
            e.setLine(line)
            raise

    def awakeFromRead(self, model):
        """Perform further initialization.

        Expected to be invoked by the model.

        """
        assert self._model is model

        for klass in self._klasses:
            supername = klass.supername()
            if supername != 'MiddleObject':
                klass.setSuperklass(self.model().klass(supername))

        for klass in self._klasses:
            klass.awakeFromRead(self)

    def __getstate__(self):
        """For pickling purposes, the back reference to the model that owns self is removed."""
        assert self._model
        attrs = self.__dict__.copy()
        del attrs['_model']
        return attrs


    ## Adding classes ##

    def addKlass(self, klass):
        """Add a class definition.

        Restrictions: Cannot add two classes with the same name.

        """
        name = klass.name()
        assert not self.has_key(name), 'Already have %s.' % name
        self._klasses.append(klass)
        self[klass.name()] = klass
        klass.setKlasses(self)


    ## Self utility ##

    def pyClassNameForAttrDict(self, dict):
        """Return class for attribute definition.

        Given a raw attribute definition (in the form of a dictionary),
        this method returns the name of the Python class that should be
        instantiated for it. This method relies primarily on dict['Type'].

        """
        typeName = dict['Type']
        if not typeName:
            if dict['Attribute']:
                raise ModelError("no type specified for attribute '%s'" % dict['Attribute'])
            else:
                raise ModelError('type specifier missing')

        # to support "list of <class>":
        if typeName.lower().startswith('list '):
            typeName = 'list'

        try:
            return self._typeNamesToAttrClassNames[typeName]
        except KeyError:
            return 'ObjRefAttr'

    def setting(self, name, default=NoDefault):
        """Return the value of a particular configuration setting taken from the model."""
        return self._model.setting(name, default)


    ## Debugging ##

    def dump(self):
        """Print each class."""
        for klass in self._klasses:
            print klass

    def debugString(self):
        return '<%s 0x%x model=%r>' % (self.__class__.__name__, id(self), getattr(self, '_model', '(none)'))