import re

from ModelObject import ModelObject
from MiscUtils import NoDefault, StringTypes
from MiddleDict import MiddleDict

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

nameRE = re.compile(r'^([A-Za-z_][A-Za-z_0-9]*)$')


class Attr(MiddleDict, ModelObject):
    """
    An Attr represents an attribute of a Klass mostly be being a dictionary-like object.
    """

    def __init__(self, dict):
        MiddleDict.__init__(self, {})
        for key, value in dict.items():
            if key == 'Attribute':
                key = 'Name'
            # @@ 2001-02-21 ce: should we always strip string fields? Probably.
            if type(value) in StringTypes and value.strip() == '':
                value = None
            self[key] = value
        match = nameRE.match(self['Name'])
        if match is None or len(match.groups()) != 1:
            raise ValueError, 'Bad name (%r) for attribute: %r.' % (self['Name'], dict)
        self._getPrefix = None
        self._setPrefix = None

    def name(self):
        return self.data['Name']

    def isRequired(self):
        """
        Returns true if a value is required for this attribute. In Python, that means the
        value cannot be None. In relational theory terms, that means the value cannot be
        NULL.
        """
        return self.boolForKey('isRequired')

    def setKlass(self, klass):
        """ Sets the klass that the attribute belongs to. """
        self._klass = klass

    def klass(self):
        """
        Returns the klass that this attribute is declared in and, therefore, belongs to.
        """
        return self._klass

    def pyGetName(self):
        """
        Returns the name that should be used for the Python "get" accessor method for this
        attribute.
        """
        if self._getPrefix is None:
            self._computePrefixes()
        name = self.name()
        if self._getCapped:
            return self._getPrefix + name[0].upper() + name[1:]
        else:
            return self._getPrefix + name

    def pySetName(self):
        """
        Returns the name that should be used for the Python "set" accessor method for this
        attribute.
        """
        if self._setPrefix is None:
            self._computePrefixes()
        name = self.name()
        if self._setCapped:
            return self._setPrefix + name[0].upper() + name[1:]
        else:
            return self._setPrefix + name

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

        Implementation note: Perhaps a future version should ask the
        klass and so on up the chain.
        """
        return self.model().setting(name, default)

    def model(self):
        return self._klass.klasses()._model

    def awakeFromRead(self):
        pass


    ## Warnings ##

    def printWarnings(self, out):
        pass


    ## Self Util ##

    def _computePrefixes(self):
        style = self.setting('AccessorStyle', 'methods').lower()
        assert style in ('properties', 'methods')
        if style == 'properties':
            self._getPrefix = '_get_'
            self._setPrefix = '_set_'
            self._getCapped = False
            self._setCapped = False
        else:
            # methods
            self._getPrefix = ''
            self._setPrefix = 'set'
            self._getCapped = False
            self._setCapped = True