from Attr import Attr


class ListAttr(Attr):
    """This is an attribute that refers to a set of other user-defined objects.

    It cannot include basic data types or instances of classes that are not part
    of the object model.

    """

    def __init__(self, attr):
        Attr.__init__(self, attr)
        self._className = attr['Type'].rsplit(None, 1)[-1]
        self._backRefAttr = None # init'ed in awakeFromRead()
        if self.get('Min') is not None:
            self['Min'] = int(self['Min'])
        if self.get('Max') is not None:
            self['Max'] = int(self['Max'])

    def className(self):
        """Return the name of the base class that this obj ref attribute points to."""
        return self._className

    def backRefAttrName(self):
        """Return the name of the back-reference attribute in the referenced class.

        It is necessary to be able to override the default back ref     to create
        data structures like trees, in which a Middle object might reference
        a parent and multiple children, all of the same class as itself.

        """
        assert self._backRefAttr is not None
        return self._backRefAttr

    def awakeFromRead(self):
        """Check that the target class and backRefAttr actually exist."""
        # Check that for "list of Foo", Foo actually exists. And,
        # Compute self._targetKlass.
        from Model import ModelError
        self._targetKlass = self.model().klass(self.className(), None)
        if not self._targetKlass:
            raise ModelError('class %s: attr %s:'
                ' cannot locate target class %s for this list.'
                % (self.klass().name(), self.name(), self.className()))

        # Compute self._backRefAttr.
        if 'BackRefAttr' in self:
            backRefName = self['BackRefAttr']
        else:
            backRefName = self.klass().name()
            attr = self._targetKlass.lookupAttr(backRefName, None)
            if attr is None:
                className = self.klass().name()
                backRefName = className[0].lower() + className[1:]
        self._backRefAttr = backRefName

        # Check that the backRefAttr, whether explicit or implicit, exists in the target class.
        backRefAttr = self._targetKlass.lookupAttr(self.backRefAttrName(), None)
        if backRefAttr is None:
            raise ModelError('class %s: attr %s: cannot locate backref attr'
                ' %s.%s for this list.' % (self.klass().name(), self.name(),
                self.className(), self.backRefAttrName()))
        backRefAttr['isBackRefAttr'] = True