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

import logging


class Widget:

    """Base class for all widgets."""

    _num_instances = 0

    def __init__(self):
        self._num_instances += 1

        #: Widget name is used for logging etc. Not visible anywhere.
        self.name = '%s#%s' % (self.__class__.__name__, self._num_instances)

        #: Parent Widget
        self.parent = None
        #: Window owning this Widget
        self.window = None
        #: Theme
        self.theme = default_theme

        #: Position inside parent widget. Modified by layout manager.
        self.pos = Point()
        #: Actual size. Modified by layout manager.
        self._size = Size(10, 10)

        #: Requested size. Layout manager will use this when placing the widget.
        self.sizereq = Size(1, 1)
        #: Minimal size of widget. Widget will never be sized smaller than this.
        self.sizemin = Size(1, 1)
        #: Maximum size of widget. Widget will never be sized bigger than this.
        #: None means no maximum size (infinite).
        self.sizemax = Size(None, None)

        #: Cursor is position where text input will occur.
        #: It is displayed on screen if widget is active.
        #: The cursor coordinates are relative to widget.
        #: Position outside of widget boundaries means no cursor (hidden).
        self._cursor = Point(-1, -1)

        #: Logger name contains full module name, class name and instance number
        self._log = logging.getLogger('%s.%s' % (self.__module__, self.name))

    ## position and size ##

    @property
    def x(self):
        return self.pos.x

    @property
    def y(self):
        return self.pos.y

    @property
    def width(self):
        return self.size.w

    @property
    def height(self):
        return self.size.h

    @property
    def size(self):
        return self._size.immutable()

    def resize(self, w, h):
        self._size.update(w, h)

    @property
    def boundaries(self):
        return Rect._make(self.pos, self._size)

    ## drawing, looks ##

    def draw(self, buffer):
        """Draw self into buffer."""
        self._log.debug('draw into %r at %s (exposed %s)',
                        buffer, buffer.origin, self.exposed(buffer))

    def set_theme(self, theme):
        self.theme = theme

    @staticmethod
    def exposed(buffer):
        """Exposed part of widget.

        Only this area needs to be drawn.

        Returns exposed Rect in widget's local coordinates,
        where 0,0 is left top corner of widget to be drawn.

        """
        return buffer.clip_rect.moved(-buffer.origin.x, -buffer.origin.y)

    @property
    def cursor(self):
        """Return cursor coordinates or None if cursor is not set
        or is set outside of widget boundaries."""
        if self._cursor in Rect._make((0, 0), self._size):
            return self._cursor

    ## input events ##

    def keypress(self, keyname, char, mod):
        self._log.debug('keypress(keyname=%r, char=%r, mod=%r)',
                        keyname, char, mod)

    def mousedown(self, button, pos):
        self._log.debug('mousedown(btn=%r, pos=%r)',
                        button, pos)

    def mouseup(self, button, pos):
        self._log.debug('mouseup(btn=%r, pos=%r)',
                        button, pos)

    def mousemove(self, button, pos, relpos):
        self._log.debug('mousemove(btn=%r, pos=%r, relpos=%r)',
                        button, pos, relpos)

    ## timeouts ##

    def add_timeout(self, delay, callback, *args):
        """Register `callback` to be called after `delay` seconds."""
        self.parent.add_timeout(self, delay, callback, *args)

    def remove_timeout(self, callback, *args):
        """Unregister callback previously registered with add_timeout.

        Removes all timeouts with the `callback` and `args`.

        """
        self.parent.remove_timeout(self, callback, *args)