# -*- coding: utf-8 -*-

from .eventsource import EventSource

from .widget import Widget

class TreeIter:

    def __init__(self, model):

        self.model = model

        self._node = self.model.root

        self._index = 0

        self._stack = []

    def __next__(self):

        node = None

        while node is None:

            try:

                node = self._node[self._index]

                if node is None:

                    raise Exception('Bad node: None')

            except IndexError:

                if len(self._stack):

                    self._node, self._index = self._stack.pop()

                else:

                    raise StopIteration

        name = node.name

        level = len(self._stack) + 1

        count = len(self._node)

        self._index += 1

        self._stack.append((self._node, self._index))

        self._node = node

        self._index = 0

        return (level, count, name)

class TreeNode(list):

    def __init__(self, name=''):

        list.__init__(self)

        self.name = name

class TreeModel(EventSource):

    def __init__(self):

        EventSource.__init__(self)

        self.addevents('change')

        self.root = TreeNode()

    def __iter__(self):

        return TreeIter(self)

    def add(self, path, names):

        if isinstance(path, str):

            path = path.split('/')

        # strip empty strings from both ends

        while path and path[0] == '':

            del path[0]

        while path and path[-1] == '':

            del path[-1]

        node = self.root

        for item in path:

            if isinstance(item, int):

                node = node[item]

            else:

                found = False

                for subnode in node:

                    if subnode.name == item:

                        node = subnode

                        found = True

                        break

                if not found:

                    item = int(item)

                    node = node[item]

        if isinstance(names, str):

            names = (names,)

        for name in names:

            node.append(TreeNode(name))

        self.emit('change')

class TreeView(Widget):

    def __init__(self, width=20, height=20, model=None):

        Widget.__init__(self, width, height)

        self._model = None

        self.setmodel(model)

        self.connect('draw', self.on_draw)

    def getmodel(self):

        '''TreeModel in use by this TreeView.'''

        return self._model

    def setmodel(self, value):

        if self._model:

            self._model.disconnect('change', self.redraw)

        self._model = value

        if self._model:

            self._model.connect('change', self.redraw)

    model = property(getmodel, setmodel)

    def on_draw(self, screen, x, y):

        screen.pushcolor('normal')

        self.draw_children(self._model.root, screen, x, y)

        screen.popcolor()

        #screen.VLINE

        #screen.LTEE

        #screen.LLCORNER

    def draw_children(self, parent, screen, x, y):

        orig_y = y

        for node in parent:

            screen.puts(x, y, '- ' + node.name)

            y += 1

            if len(node):

                y += self.draw_children(node, screen, x + 2, y)

        return y - orig_y