from zope.interface.interfaces import ComponentLookupError

from zope.interface import providedBy
from zope.component import getGlobalSiteManager, getMultiAdapter

from graph.interfaces import IBaseComponent


gsm = getGlobalSiteManager()


class BaseAdapter(object):
    """
    Base for all Adapters
    """
#    implements(IBaseAdapter)

    def __init__(self, obj):
        """
        Gets an Object to be adapted
        """
        self.obj = obj

class BaseComponent(object):
    """
    """

    def __init__(self, parent):
        self.parent = parent
        self.items = []

    def addItem(self, item):
        self.items.append(item)

    def setup(self, *args, **kwargs):
        pass


class BaseFactory(object):
    def __init__(self, obj, *args, **kwargs):
        """
        Gets an Object to be adapted
        """
        self.obj = obj
        self.args = args
        self.kwargs = kwargs

    def __call__(self, *args, **kwargs):
        parent_vector = self.traverse_parents()
        adapter = self.find_adapter(parent_vector)
        adapter.setup(*args, **kwargs)
        return adapter

    def find_adapter(self, parent_vector):
        for i in range(len(parent_vector)):
            try:
                adapter = getMultiAdapter(parent_vector[i:], self.target_interface)
            except ComponentLookupError:
                pass
            else:
                if adapter :
                    return adapter

    def traverse_parents(self):
        """
        Retrieve the vector of all component parents up to the top level component which has no parent
        """
        parent_vector = [self.obj]
        obj = self.obj
        while obj.parent:
            obj = obj.parent
            parent_vector.append(obj)
        parent_vector.reverse()
        return parent_vector

    def getComponentInterfaceOf(self, obj):
        """
        Retrieve the interfacess a certain instance is providing.
        Filter out the interface that belongs to our framework.
        """
        for interface in providedBy(obj):
            if isinstance(interface, IBaseComponent.__class__):
                return interface