from tuikit.core.signal import Signal

from tuikit.core.coords import Point, Size, Rect

from tuikit.core.theme import default_theme

from contextlib import contextmanager

class Cell:

    """Character buffer cell.

    Cell contains one character and its attribute.

    """

    __slots__ = ('char', 'attr')

    def __init__(self, char=' ', attr=0):

        self.char = char

        self.attr = attr

    def set(self, char, attr):

        self.char = char

        self.attr = attr

class BufferOperationsMixin:

    def draw(self, buffer, x=0, y=0):

        """Draw another buffer onto this buffer at x/y coords."""

        for bufy in range(buffer.size.h):

            for bufx in range(buffer.size.w):

                char, attr_desc = buffer.get(bufx, bufy)

                self.setattr(attr_desc)

        """Output string of characters."""

            x += 1

        """Draw horizontal line."""

        """Draw vertical line."""

        for i in range(h):

        """Fill rectangular area.

        Fill whole buffer if width or height is not specified (zero).

        """

        w = self.size.w if not w else w

        h = self.size.h if not h else h

        for i in range(h):

    def frame(self, x=0, y=0, w=0, h=0, theme=default_theme):

        """Draw rectangular frame.

        Frame whole buffer if width or height is not specified (zero).

        Use line-drawing characters from `style` bank.

        """

        w = self.size.w if not w else w

        h = self.size.h if not h else h

    @contextmanager

    def attr(self, attr_desc):

        """Set attribute for block of commands, then restore previous attribute."""

        original_attr = self.getattr()

        try:

            self.setattr(attr_desc)

            yield

        finally:

            self.setattr(original_attr)

class BufferClippingMixin:

    @property

    def clip_rect(self):

        """Return clipping rectangle in buffer coordinates."""

        try:

            return self._clip_rect

        except AttributeError:

            self.clip_rect = None

            return self._clip_rect

    @clip_rect.setter

    def clip_rect(self, value):

        if value:

            self._clip_rect = value

        else:

            self._clip_rect = Rect(0, 0, self.size.w, self.size.h)

    def testxy(self, x, y):

        """Test if x/y coords are inside current clipping region."""

        return (x, y) in self.clip_rect

    @contextmanager

    def clip(self, x, y, w, h):

        """Update clipping region as intersection of original and new region.

        Restore original region before returning.

        """

        original_rect = self.clip_rect

        try:

            self.clip_rect = original_rect.intersect(Rect(x, y, w, h))

            yield

        finally:

            self.clip_rect = original_rect

class BufferOriginMixin:

    @property

    def origin(self):

        """Origin coordinates for `putch`.

        Drawing is relative to origin.

        """

        try:

            return self._origin

        except AttributeError:

            self._origin = Point(0, 0)

            return self._origin

    @origin.setter

    def origin(self, value):

        self.origin.update(value)

    def reset_origin(self):

        self.origin.update(0, 0)

    def move_origin(self, relx, rely):

        self.origin.move(relx, rely)

    @contextmanager

    def moved_origin(self, relx, rely):

        ox, oy = self.origin

        try:

            self.origin.move(relx, rely)

            yield

        finally:

            self.origin.update(ox, oy)

class Buffer(BufferOperationsMixin, BufferClippingMixin, BufferOriginMixin):

    """Rectangular character buffer.

    Retains characters and colors drawn into it

    until resized. Contents are reset when resized.

    """

    def __init__(self, w=0, h=0):

        self._size = Size(w, h)

        self._data = None

        self._attr_descs = ['default']

        self._attr_map = {'default': 0}

        self._current_attr = 0

        self.clear()

        self.sig_resized = Signal()

    @property

    def size(self):

        """Width and height of buffer, in characters."""

        return self._size.readonly()

    def resize(self, w, h):

        """Resize buffer."""

        self._size.update(w, h)

        self.clear()

        self.sig_resized(w, h)

    def clear(self):

        """Reset buffer data."""

        self._data = [Cell() for _i in range(self._size.w * self._size.h)]

        self.clip_rect = None

    def get(self, x, y):

        """Get cell data at `x`, `y` coords.

        Returns tuple (char, attr_desc).

        """

        cell = self._data[y * self._size.w + x]

        return cell.char, self._attr_descs[cell.attr]

    def getattr(self):

        """Get current attribute."""

        return self._attr_descs[self._current_attr]

    def setattr(self, attr_desc):

        """Set attribute to be used for subsequent draw operations."""

        if attr_desc in self._attr_map:

            attr = self._attr_map[attr_desc]

        else:

            attr = len(self._attr_descs)

            self._attr_descs.append(attr_desc)

            self._attr_map[attr_desc] = attr

        self._current_attr = attr

        """Set character on `x`, `y` coords to `ch`.

        Coords are adjusted by origin.

        """

        x += self.origin.x

        y += self.origin.y

        if self.testxy(x, y):

            self._data[y * self._size.w + x].set(ch, self._current_attr)

class ProxyBuffer(BufferOperationsMixin, BufferClippingMixin, BufferOriginMixin):

    """Special buffer which proxies the operations

    to another buffer or buffer-like class."""

    def __init__(self, target):

        self.target = target

        self.sig_resized = Signal()

    @property

    def size(self):

        return self.target.size

    def resize(self, w, h):

        """Resize buffer."""

        self.target.resize(w, h)

        self.sig_resized(w, h)

    def clear(self):

        """Reset buffer data."""

        self.target.clear()

        self.clip_rect = None

    def get(self, x, y):

        """Get cell data at `x`, `y` coords."""

        return self.target.get(x, y)

    def getattr(self):

        """Get current attribute."""

        return self.target.getattr()

    def setattr(self, attr_desc):

        """Set attribute to be used for subsequent draw operations."""

        self.target.setattr(attr_desc)

        """Set character on `x`, `y` coords to `ch`.

        Coords are adjusted by origin.

        """

        x += self.origin.x

        y += self.origin.y

        if self.testxy(x, y):