import curses.ascii

import math

import logging

from tuikit.driver.driver import Driver

class CursesWDriver(Driver):

    key_names = {

        '\t':                   'tab',

        '\n':                   'enter',

        '\x1b':                 'escape',

    }

    key_map = {

        curses.KEY_UP:          'up',

        curses.KEY_DOWN:        'down',

        curses.KEY_LEFT:        'left',

        curses.KEY_RIGHT:       'right',

        curses.KEY_IC:          'insert',

        curses.KEY_DC:          'delete',

        curses.KEY_HOME:        'home',

        curses.KEY_END:         'end',

        curses.KEY_PPAGE:       'pageup',

        curses.KEY_NPAGE:       'pagedown',

        curses.KEY_BACKSPACE:   'backspace',

        curses.KEY_BTAB:        'shift+tab',

    }

    for _i in range(1, 13):

        key_map[curses.KEY_F0 + _i] = 'f' + str(_i)

    color_map = {

        'default':      (-1,                    0),

        'black':        (curses.COLOR_BLACK,    0),

        'blue':         (curses.COLOR_BLUE,     0),

        'green':        (curses.COLOR_GREEN,    0),

        'cyan':         (curses.COLOR_CYAN,     0),

        'red':          (curses.COLOR_RED,      0),

        'magenta':      (curses.COLOR_MAGENTA,  0),

        'brown':        (curses.COLOR_YELLOW,   0),

        'lightgray':    (curses.COLOR_WHITE,    0),

        'gray':         (curses.COLOR_BLACK,    curses.A_BOLD),

        'lightblue':    (curses.COLOR_BLUE,     curses.A_BOLD),

        'lightgreen':   (curses.COLOR_GREEN,    curses.A_BOLD),

        'lightcyan':    (curses.COLOR_CYAN,     curses.A_BOLD),

        'lightred':     (curses.COLOR_RED,      curses.A_BOLD),

        'lightmagenta': (curses.COLOR_MAGENTA,  curses.A_BOLD),

        'yellow':       (curses.COLOR_YELLOW,   curses.A_BOLD),

        'white':        (curses.COLOR_WHITE,    curses.A_BOLD),

    }

    attr_map = {

        'bold':         curses.A_BOLD,

        'underline':    curses.A_UNDERLINE,

        'standout':     curses.A_STANDOUT,  # inverse bg/fg

        'blink':        curses.A_BLINK,

    }

    def __init__(self):

        Driver.__init__(self)

        self._log = logging.getLogger(__name__)

        self.stdscr = None

        self.cursor = None

        self.colors = {}     # maps names to curses attributes

        self.colorpairs = {} # maps tuple (fg,bg) to curses color_pair

        self._mouse_last_pos = (None, None)

        self._mouse_last_bstate = None

    ## initialization, finalization ##

    def init(self):

        """Initialize curses"""

        self.stdscr = curses.initscr()

        curses.start_color()

        curses.use_default_colors()

        curses.noecho()

        curses.cbreak()

        self.stdscr.keypad(1)

        self.stdscr.immedok(0)

        self.size.h, self.size.w = self.stdscr.getmaxyx()

        curses.curs_set(False)  # hide cursor

        curses.mousemask(curses.ALL_MOUSE_EVENTS | curses.REPORT_MOUSE_POSITION)

        curses.mouseinterval(0)  # do not wait to detect clicks, we use only press/release

    def close(self):

        self.stdscr.keypad(0)

        curses.echo()

        curses.nocbreak()

        curses.endwin()

    ## drawing ##

    def clear(self):

        self.stdscr.erase()

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

        try:

            if isinstance(ch, int):

                self.stdscr.addch(y, x, ch)

            elif isinstance(ch, str) and len(ch) == 1:

                self.stdscr.addstr(y, x, ch)

            else:

                raise TypeError('Integer or one-char string is required.')

        except curses.error as e:

            self._log.exception('putch(%r, %s, %s) error:' % (ch, x, y))

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

        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 flush(self):

        if self.cursor:

            self.stdscr.move(self.cursor.y, self.cursor.x)

            curses.curs_set(True)

        else:

            curses.curs_set(False)

        self.stdscr.refresh()

    ## colors, attributes ##

    def setattr(self, attr_desc):

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

        attr = self.colors.get(attr_desc, None)

        if attr is None:

            # first encountered `attr_desc`, initialize

            fg, bg, attrs = self._parse_attr_desc(attr_desc)

            fgcol, fgattr = self.color_map[fg]

            bgcol, _bgattr = self.color_map[bg]

            colpair = self._getcolorpair(fgcol, bgcol)

            attr = curses.color_pair(colpair) | self._parseattrs(attrs) | fgattr

            self.colors[attr_desc] = attr

        self.stdscr.attrset(attr)

    def _getcolorpair(self, fgcol, bgcol):

        pair = (fgcol, bgcol)

        if pair in self.colorpairs:

            return self.colorpairs[pair]

        num = len(self.colorpairs) + 1

        curses.init_pair(num, fgcol, bgcol)

        self.colorpairs[pair] = num

        return num

    def _parseattrs(self, attrs):

        res = 0

        for a in attrs:

            res = res | self.attr_map[a]

        return res

    ## input, events ##

    def getevents(self, timeout=None):

        """Process input, return list of events.

        timeout -- float, in seconds (None=infinite)

        Returns:

            [('event', param1, ...), ...]

        """

        # Set timeout

        if timeout is None:

            # wait indefinitely

            curses.cbreak()

        elif timeout > 0:

            # wait

            timeout_tenths = math.ceil(timeout * 10)

            curses.halfdelay(timeout_tenths)

        else:

            # timeout = 0 -> no wait

            self.stdscr.nodelay(1)

        # Get key or char

        c = self.stdscr.get_wch()

        res = []

        if c == -1:

            # Timeout

            return res

        elif c == curses.KEY_MOUSE:

            res += self._process_mouse()

        elif c == curses.KEY_RESIZE:

            self.size.h, self.size.w = self.stdscr.getmaxyx()

        elif isinstance(c, int):

        else:

            keyname = self.key_names.get(c)

        return res

    def _process_mouse(self):

        out = []

        try:

            _id, x, y, _z, bstate = curses.getmouse()

        except curses.error:

            return out

        if bstate & curses.REPORT_MOUSE_POSITION:

            if self._mouse_last_pos != (x, y):

                if self._mouse_last_pos[0] is not None:

                    relx = x - (self._mouse_last_pos[0] or 0)

                    rely = y - (self._mouse_last_pos[1] or 0)

                    out += [('mousemove', 0, x, y, relx, rely)]

                self._mouse_last_pos = (x, y)

        # we are interested only in changes, not buttons already pressed before event

        if self._mouse_last_bstate is not None:

            old = self._mouse_last_bstate

            new = bstate

            bstate = ~old & new

            self._mouse_last_bstate = new

        else:

            self._mouse_last_bstate = bstate

        if bstate & curses.BUTTON1_PRESSED:

            out += [('mousedown', 1, x, y)]

        if bstate & curses.BUTTON2_PRESSED:

            out += [('mousedown', 2, x, y)]

        if bstate & curses.BUTTON3_PRESSED:

            out += [('mousedown', 3, x, y)]

        if bstate & curses.BUTTON1_RELEASED:

            out += [('mouseup', 1, x, y)]

        if bstate & curses.BUTTON2_RELEASED:

            out += [('mouseup', 2, x, y)]

        if bstate & curses.BUTTON3_RELEASED:

            out += [('mouseup', 3, x, y)]

        # reset last pos when pressed/released

        if len(out) > 0 and out[-1][0] in ('mousedown', 'mouseup'):

            self._mouse_last_pos = (None, None)

        return out

        """Parse keynames in form "shift+tab", return (keyname, mod)."""

        mod_set = set()

        if '+' in keyname:

            parts = keyname.split('+')

            for mod in parts[:-1]:

                assert(mod in ('shift', 'alt', 'ctrl', 'meta'))

                mod_set.add(mod)

            keyname = parts[-1]

        return keyname, mod_set

driver_class = CursesWDriver