import collections
from typing import Deque, List, Optional, Tuple

from .element import Id, RenderedElement
from .markup import AttributedText

__all__ = ["TreeList"]

class TreeList:
    """
    This class is the stage between tree-like Element structures and lines of
    text like the TreeDisplay's DisplayLines.

    It keeps track of the results of rendering Element trees, and also the top
    and bottom tree's ids, so the TreeList can be expanded easily by appending
    trees to the top and bottom.

    Despite its name, the "trees" it stores are just flat lists, and they're
    stored in a flat deque one message at a time. Its name comes from how i is
    used with rendered Element trees.
    """

    def __init__(self,
            tree: List[RenderedElement],
            anchor_id: Id,
            ) -> None:
        self._deque: Deque[RenderedElement] = collections.deque()

        # The offsets can be thought of as the index of a line relative to the
        # anchor's first line.
        #
        # The upper offset is the index of the uppermost message's first line.
        # The lower offset is the index of the lowermost message's LAST line.
        self._upper_offset: int
        self._lower_offset: int

        # The upper and lower tree ids are the ids of the uppermost or
        # lowermost tree added to the TreeList. They can be used to request the
        # previous or next tree from an ElementSupply.
        self._upper_tree_id: Id
        self._lower_tree_id: Id

        self._add_first_tree(tree, anchor_id)

    @property
    def upper_offset(self) -> int:
        return self._upper_offset

    @property
    def lower_offset(self) -> int:
        return self._lower_offset

    @property
    def upper_tree_id(self) -> Id:
        return self._upper_tree_id

    @property
    def lower_tree_id(self) -> Id:
        return self._lower_tree_id

    def offset_by(self, delta: int) -> None:
        """
        Change all the TreeList's offsets by a delta (which is added to each
        offset).
        """

        self._upper_offset += delta
        self._lower_offset += delta

    def _add_first_tree(self,
            tree: List[RenderedElement],
            anchor_id: Id
            ) -> None:
        if len(tree) == 0:
            raise ValueError("The tree must contain at least one element")

        tree_id = tree[0].element.id
        self._upper_tree_id = tree_id
        self._lower_tree_id = tree_id

        offset = 0
        found_anchor = False

        for rendered in tree:
            if rendered.element.id == anchor_id:
                found_anchor = True
                self._upper_offset = -offset

            offset += rendered.height

        if not found_anchor:
            raise ValueError("The initial tree must contain the anchor")

        # Subtracting 1 because the lower offset is the index of the lowermost
        # message's last line, not the first line of a hypothetical message
        # below that.
        self._lower_offset = offset - 1

        self._deque.extend(tree)

    def add_above(self, tree: List[RenderedElement]) -> None:
        """
        Add a rendered tree above all current trees.
        """

        if len(tree) == 0:
            raise ValueError("The tree must contain at least one element")

        self._upper_tree_id = tree[0].element.id

        for rendered in reversed(tree):
            self._deque.appendleft(rendered)
            self._upper_offset -= rendered.height

        # Alternative to the above for loop
        #delta = sum(map(lambda r: r.height, tree))
        #self._upper_offset -= delta
        #self._deque.extendLeft(reversed(tree))

    def add_below(self, tree: List[RenderedElement]) -> None:
        """
        Add a rendered tree below all current trees.
        """

        if len(tree) == 0:
            raise ValueError("The tree must contain at least one element")

        self._lower_tree_id = tree[0].element.id

        for rendered in tree:
            self._deque.append(rendered)
            self._lower_offset += rendered.height

        # Alternative to the above for loop
        #delta = sum(map(lambda r: r.height, tree))
        #self._lower_offset += delta
        #self._deque.extend(tree)

    def to_lines(self,
            start: Optional[int] = None,
            stop: Optional[int] = None,
            ) -> List[Tuple[AttributedText, RenderedElement]]:

        offset = self.upper_offset
        lines: List[Tuple[AttributedText, RenderedElement]] = []

        # I'm creating this generator instead of using two nested for loops
        # below, because I want to be able to break out of the for loop without
        # the code getting too ugly, and because it's fun :)
        all_lines = ((line, rendered)
                for rendered in self._deque
                for line in rendered.lines)

        for line, rendered in all_lines:
            after_start = start is not None and offset >= start
            before_stop = stop is not None and offset <= stop

            if after_start and before_stop:
                lines.append((line, rendered))

            if not before_stop:
                break

            offset += 1

        return lines