from zope.interface import implements, implementsOnly, Interface
from zope.component import adapts, getGlobalSiteManager

from graph.interfaces import ITickLabelAdapter
from graph.interfaces import IAxis
from graph.interfaces import IViewBox
from graph.interfaces import IImage
from graph.interfaces import IBaseAdapter


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


class TickLabelAdapter(BaseAdapter):
    """
    Generates Ticklabels for an axis
    """
    implementsOnly(ITickLabelAdapter)
    adapts(IAxis)

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

    def render(self):
        return map(str, range(self.axis.start, self.axis.end))

gsm.registerAdapter(TickLabelAdapter)


class Axis(BaseComponent):
    """
    Represents an axis
    """

    implements(IAxis)
    adapts(Interface)

    def __init__(self, parent, orientation=None, start=None, end=None):
        super(Axis, self).__init__(parent)
        self.orientation = orientation
        self.start = start
        self.end = end

    def get_tick_labels(self):
        return ITickLabelAdapter(self).render()

    def render(self):
        return 'axis: ' + self.orientation + ':' + ' '.join(self.get_tick_labels())

gsm.registerAdapter(Axis)


class ViewBox(BaseComponent):
    """
    Drawing area of a plot. THe drawing ares may have an unlimited number of axis
    """
    implements(IViewBox)
    adapts(Interface)


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

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

    def render(self):
        result = []
        for item in self.items:
            result.append(item.render())

        return '\n'.join(result)

gsm.registerAdapter(ViewBox)


class Image(BaseComponent):
    """
    A image representing f(x,y) values
    """
    implements(IImage)
    adapts(Interface)


    def __init__(self, parent, data):
        super(Image, self).__init__(parent)
        self.data = data

    def render(self):
        return 'Image: Rendered image'

gsm.registerAdapter(Image)