# used for filtering out 'builtin' methods upon dir() of custom class
std_class_methods = dir(object)
std_instance_methods = dir(object())

# ------------- Components -------------------------------
class _ComponentAccessor(object):
    def __init__(self):
        # flags to prevent infinite recursion during obj '__get__'
        self._breaks = {}

    def __get__(self, instance, owner):
        # if an 'instance' is passed
        #   return dict of {component attr: component value}
        # else use 'owner'
        #   return dict of {component attr: component obj}
        if instance is None:
            obj = owner
        else:
            obj = instance
        if self._get_break(obj):
            return None
        self._set_break(obj)
        _d = {}
        attrs = [a for a in dir(owner) if a not in std_class_methods]
        for attr in attrs:
            component = getattr(owner, attr)
            if getattr(component, '_is_component', False):
                _d[attr] = getattr(obj, attr)
        self._release_break(obj)
        return _d

    def __set__(self, instance, value):
        raise ValueError("Cannot change a '_ComponentAccessor'")
    def __delete__(self, instance, value):
        raise ValueError("Cannot delete a '_ComponentAccessor'")

    def _get_break(self, obj):
        return self._breaks.get(id(obj), False)
    def _set_break(self, obj):
        self._breaks[id(obj)] = True
    def _release_break(self, obj):
        self._breaks[id(obj)] = False

class ClassWithComponents(object):
    """ inherit from this to provide component introspection """
    # introspection flag
    _utilizes_components = True
    # introspection 'property' (read only) that will return
    #   the class' current Components
    components = _ComponentAccessor()


class Component(object):
    """ the data descriptor to add to a class """
    _is_component = True

    def __init__(self, type=None):
        """ type - verify component is set to an instance
            of 'type' when assigned
        """
        self._type = type
        self._cache = {}    # TODO: make into weakref dict

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return self._cache.get(id(instance), None)

    def __set__(self, instance, value):
        # check value against self._type
        if value is not None:
            if self._type is not None and not isinstance(value, self._type):
                raise TypeError("Invalid type '%s' for component! Needs to be '%s'" %\
                    (value.__class__.__name__, self._type.__name__,))
        self._cache[id(instance)] = value

    def __delete__(self, instance):
        del(self._cache[id(instance)])
# ------------- /Components ------------------------------



# ------------- Abilities --------------------------------
class _Ability(object):
    def __init__(self, method_name, *bound_methods):
        self.name = method_name
        # TODO: could look at method # of args, etc...
        self._methods = []
        for bm in bound_methods:
            self.append(bm)

    def __str__(self):
        return self.name

    def __call__(self, *args, **kwargs):
        if len(self._methods) == 0:
            return None
        elif len(self._methods) == 1:
            # only 1 method, return its return value
            return self._methods[0](*args, **kwargs)
        else:
            # call all of our methods in order, no return value
            for m in self._methods:
                m(*args, **kwargs)

    def __add__(self, other):
        if not isinstance(other, _Ability):
            raise TypeError("Can only add _Abilities together!")
        if other.name != self.name:
            raise ValueError("Abilities have mismatched names!")
        meth_list = self._methods + other._methods
        return _Ability(self.name, *meth_list)

    def append(self, bound_method):
        if bound_method in self._methods:
            raise ValueError("Cannot add duplicate methods to ability!")
        self._methods.append(bound_method)


class _AbilityAccessor(tuple):
    """ placeholder object for ability methods """
    def __new__(cls, abilities=None):
        if abilities is None:
            abilities = []
        # check for duplicate ability.names combine them
        _ab_d = {}
        for abil in abilities:
            if abil.name not in _ab_d:
                _ab_d[abil.name] = []
            _ab_d[abil.name].append(abil)
        abilities = []
        for name, ab_list in _ab_d.items():
            abil = ab_list.pop(0)
            for ab in ab_list:
                abil += ab
            abilities.append(abil)
        return tuple.__new__(cls, abilities)

    def __init__(self, abilities=None):
        tuple.__init__(self)
        # create a method on self to pass call onto ability
        # ignore passed in 'abilities' arg, use self
        for ab in self:
            object.__setattr__(self, ab.name, ab)

    def __add__(self, other):
        if isinstance(other, _AbilityAccessor):
            abs = tuple.__add__(self, other)
        elif isinstance(other, _Ability):
            abs = []
            abs.extend(self)
            abs.append(other)
        else:
            raise TypeError("Can only add to other _AbilityAccessors!")
        return _AbilityAccessor(abs)


class _AbilityLookup(object):
    def __init__(self):
        # dict of flags to prevent infinite recursion during '__get__'
        self._breaks = {}    # id(obj) -> True/False

    def __get__(self, instance, owner):
        # if an 'instance' is passed
        #   return dict of {ability attr: [ability value]}
        # else use 'owner'
        #   return dict of {ability attr: ability obj}
        _d = {}
        if instance is None:
            if self._get_break(owner):
                return None
            self._set_break(owner)
            attrs = [a for a in dir(owner) if a not in std_class_methods]
            for attr in attrs:
                obj = getattr(owner, attr)
                if getattr(obj, '_is_ability_method', False):
                    _d[attr] = obj
            self._release_break(owner)
            return _d
        else:
            if self._get_break(instance):
                return None
            self._set_break(instance)
            ability_accessor = _AbilityAccessor()
            attrs = [a for a in dir(instance) if a not in std_instance_methods]
            for attr in attrs:
                obj = getattr(instance, attr)
                # check if the obj is an ability method
                if getattr(obj, '_is_ability_method', False):
                    ability_accessor += _Ability(attr, obj)
                # else check if the obj is a class with abilities
                elif getattr(obj, '_utilizes_abilities', False):
                    # get that obj's abilities and extend ours
                    ability_accessor += obj.abilities
            self._release_break(instance)
            return ability_accessor

    def __set__(self, instance, value):
        raise ValueError("Cannot change an '_AbilityLookup'")
    def __delete__(self, instance, value):
        raise ValueError("Cannot delete an '_AbilityLookup'")

    def _get_break(self, obj):
        return self._breaks.get(id(obj), False)
    def _set_break(self, obj):
        self._breaks[id(obj)] = True
    def _release_break(self, obj):
        self._breaks[id(obj)] = False

def abilitymethod(func):
    """ method decorator to mark it as an 'abilitymethod' """
    # check if func has an 'invalid' name
    if func.func_name in dir(_AbilityAccessor):
        raise ValueError("Invalid name for an abilitymethod! '%s'" %\
                (func.func_name,))
    func._is_ability_method = True
    return func

class ClassWithAbilities(object):
    """ inherit from this to provide ability introspection """
    _utilizes_abilities = True
    abilities = _AbilityLookup()

# ------------- /Abilities -------------------------------


if __name__ == "__main__":
    class RobotFirmware(ClassWithAbilities):
        @abilitymethod
        def power_on(self):
            print 'RobotFirmware.power_on'
            self.power_on_checks()

        def power_on_checks(self):
            """ demonstrates object encapsulation of methods """
            print 'RobotFirmware.power_on_checks'

    class UpgradedRobotFirmware(RobotFirmware):
        @abilitymethod
        def laser_eyes(self, wattage):
            print "UpgradedRobotFirmware.laser_eyes(%d)" % wattage

    class RobotArm(ClassWithAbilities):
        @abilitymethod
        def power_on(self):
            print 'RobotArm.power_on'

        @abilitymethod
        def bend_girder(self):
            print 'RobotArm.bend_girder'



    class Robot(ClassWithComponents, ClassWithAbilities):
        firmware = Component(RobotFirmware)
        arm = Component()

        @abilitymethod
        def power_on(self):
            print 'Robot.power_on'

        def kill_all_humans(self):
            """ demonstrates a method that components didn't take over """
            print 'Robot.kill_all_humans'


    print '-- Components --------'
    print 'Robot.components:', Robot.components
    r = Robot()
    print 'r.components:    ', r.components
    print '\tuploading firmware to robot...'
    try:
        r.firmware  = RobotArm()
    except Exception, e:
        print "\tMALFUNCTION! %s" % (e,)
    print '\tuploading firmware to robot try #2...'
    r.firmware = RobotFirmware()
    print '\t...success'
    print 'r.components:    ', r.components
    del(r)
    print '----------------------'
    print ''
    print '-- Abilities ---------'
    print "Robot.abilities:", Robot.abilities
    r = Robot()
    print "r.abilities:    ", r.abilities
    print "r.abilities (by name): ", [ab.name for ab in r.abilities]
    print '\tuploading firmware to robot...'
    r.firmware = RobotFirmware()
    print "r.abilities (by name): ", [ab.name for ab in r.abilities]
    print "r.firmware.abilities:  ", r.firmware.abilities
    print '\tattaching arm to robot...'
    r.arm = RobotArm()
    print "r.abilities (by name): ", [ab.name for ab in r.abilities]
    print "\twhat abilities does 'UpgradedRobotFirmware' provide?"
    print "\t", [x for x in UpgradedRobotFirmware.abilities]
    print "\tOooh laser eyes! upgrading...",
    r.firmware = UpgradedRobotFirmware()
    print "...done"
    print "\tPowering on..."
    r.abilities.power_on()
    print "\tTesting out laser eyes"
    r.abilities.laser_eyes(300)
    print "\tDeleting firmware"
    r.firmware = None
    print "\tPowering on..."
    r.abilities.power_on()
    print '----------------------'