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)

                self.putch(char, x + bufx, y + bufy)

    def puts(self, s, x=0, y=0):

        """Output string of characters."""

        for ch in s:

            self.putch(ch, x, y)

            x += 1

    def hline(self, ch='-', x=0, y=0, w=0):

        """Draw horizontal line."""

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

        self.puts([ch] * w, x, y)

    def vline(self, ch='|', x=0, y=0, h=0):

        """Draw vertical line."""

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

        for i in range(h):

            self.putch(ch, x, y + i)

    def fill(self, ch=' ', x=0, y=0, w=0, h=0):

        """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):

            self.hline(ch, x, y + i, w)

    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

        self.putch(theme.frame_ulcorner,    x,      y)

        self.putch(theme.frame_urcorner,    x+w-1,  y)

        self.putch(theme.frame_llcorner,    x,      y+h-1)

        self.putch(theme.frame_lrcorner,    x+w-1,  y+h-1)

        self.hline(theme.frame_hline,       x+1,    y,      w-2)

        self.hline(theme.frame_hline,       x+1,    y+h-1,  w-2)

        self.vline(theme.frame_vline,       x,      y+1,    h-2)

        self.vline(theme.frame_vline,       x+w-1,  y+1,    h-2)

    @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."""

    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

    def putch(self, ch, x=0, y=0):

        """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)

    def putch(self, ch, x=0, y=0):

        """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.target.putch(ch, x, y)