# -*- coding: utf-8 -*-

import curses

import curses.ascii

import locale

import logging

from .common import Rect

class MouseEvent:

    def __init__(self, x=0, y=0):

        self.x = x   # global coordinates

        self.y = y

        self.wx = x  # local widget coordinates

        self.wy = y

        self.px = 0  # parent coordinates

        self.py = 0

        self.button = 0

    def childevent(self, child):

        ev = MouseEvent(self.x, self.y)

        # original local coordinates are new parent coordinates

        ev.px = self.wx

        ev.py = self.wy

        # update local coordinates

        ev.wx = self.wx - child.x

        ev.wy = self.wy - child.y

        return ev

class BackendCurses:

    xterm_codes = (

        (0x09,                      'tab'           ),

        (0x0a,                      'enter'         ),

        (0x7f,                      'backspace'     ),

        (0x1b,0x4f,0x50,            'f1'            ),

        (0x1b,0x4f,0x51,            'f2'            ),

        (0x1b,0x4f,0x52,            'f3'            ),

        (0x1b,0x4f,0x53,            'f4'            ),

        (0x1b,0x5b,0x31,0x35,0x7e,  'f5'            ),

        (0x1b,0x5b,0x31,0x37,0x7e,  'f6'            ),

        (0x1b,0x5b,0x31,0x38,0x7e,  'f7'            ),

        (0x1b,0x5b,0x31,0x39,0x7e,  'f8'            ),

        (0x1b,0x5b,0x32,0x30,0x7e,  'f9'            ),

        (0x1b,0x5b,0x32,0x31,0x7e,  'f10'           ),

        (0x1b,0x5b,0x32,0x33,0x7e,  'f11'           ),

        (0x1b,0x5b,0x32,0x34,0x7e,  'f12'           ),

        (0x1b,0x5b,0x32,0x7e,       'insert'        ),

        (0x1b,0x5b,0x33,0x7e,       'delete'        ),

        (0x1b,0x5b,0x35,0x7e,       'pageup'        ),

        (0x1b,0x5b,0x36,0x7e,       'pagedown'      ),

        (0x1b,0x5b,0x46,            'end'           ),

        (0x1b,0x5b,0x48,            'home'          ),

    )

    def __init__(self, screen):

        self.screen = screen

        self.height, self.width = screen.getmaxyx()

        self.clipstack = []

        self.colorstack = []

        self.inputqueue = []

        self.mbtnstack = []

        self.log = logging.getLogger('tuikit')

        # initialize curses

        curses.curs_set(False)

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

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

        screen.immedok(0)

        screen.keypad(0)

        curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)

        curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_CYAN)

        curses.init_pair(3, curses.COLOR_WHITE, curses.COLOR_CYAN)

        curses.init_pair(4, curses.COLOR_WHITE, curses.COLOR_BLUE)

        curses.init_pair(5, curses.COLOR_CYAN, curses.COLOR_BLUE)

        self.BOLD = curses.A_BOLD

        self.BLINK = curses.A_BLINK

        self.UNDERLINE = curses.A_UNDERLINE

        # http://en.wikipedia.org/wiki/List_of_Unicode_characters#Geometric_shapes

        self.UP_ARROW = '▲' #curses.ACS_UARROW

        self.DOWN_ARROW = '▼' #curses.ACS_DARROW

        # http://en.wikipedia.org/wiki/Box-drawing_characters

        self.LIGHT_SHADE = '░' #curses.ACS_BOARD

        self.MEDIUM_SHADE = '▒'

        self.DARK_SHADE = '▓'

        self.BLOCK = '█'

        self.COLUMN = '▁▂▃▄▅▆▇█'

        self.CORNER_ROUND = '╭╮╰╯'

        self.CORNER = '┌┐└┘'

        self.LINE = '─━│┃┄┅┆┇┈┉┊┋'

        self.HLINE = '─' # curses.ACS_HLINE

        self.VLINE = '│' # curses.ACS_VLINE

        self.ULCORNER = '┌' # curses.ACS_ULCORNER

        self.URCORNER = '┐' # curses.ACS_URCORNER

        self.LLCORNER = '└' # curses.ACS_LLCORNER

        self.LRCORNER = '┘' # curses.ACS_LRCORNER

        self.LTEE = '├'

        self.RTEE = '┤'

    ## clip operations ##

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

        newclip = Rect(x, y, w, h)

        if len(self.clipstack):

            oldclip = self.clipstack[-1]

            newclip = self.intersect(oldclip, newclip)

        self.clipstack.append(newclip)

    def popclip(self):

        self.clipstack.pop()

    def testclip(self, x, y):

        # no clip rectangle on stack => passed

        if not len(self.clipstack):

            return True

        # test against top clip rect from stack

        clip = self.clipstack[-1]

        if x < clip.x or y < clip.y \

        or x >= clip.x + clip.w or y >= clip.y + clip.h:

            return False

        # passed

        return True

    def intersect(self, r1, r2):

        x1 = max(r1.x, r2.x)

        y1 = max(r1.y, r2.y)

        x2 = min(r1.x + r1.w, r2.x + r2.w)

        y2 = min(r1.y + r1.h, r2.y + r2.h)

        if x1 >= x2 or y1 >= y2:

            return Rect()

        return Rect(x1, y1, x2-x1, y2-y1)

    def union(self, r1, r2):

        x = min(r1.x, r2.x)

        y = min(r1.y, r2.y)

        w = max(r1.x + r1.w, r2.x + r2.w) - x

        h = max(r1.y + r1.h, r2.y + r2.h) - y

        return Rect(x, y, w, h)

    ## attributes ##

    def pushcolor(self, col, attr=0):

        if type(col) is tuple:

            col, attr = col

        if attr == 'bold':

            attr = self.BOLD

        self.screen.attrset(curses.color_pair(col) | attr)

        self.colorstack.append((col, attr))

    def popcolor(self):

        self.colorstack.pop()

        if len(self.colorstack):

            col, attr = self.colorstack[-1]

        else:

            col, attr = 0, 0

        self.screen.attrset(curses.color_pair(col) | attr)

    ## drawing ##

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

        if not self.testclip(x, y):

            return

        try:

            if type(c) is str and len(c) == 1:

                self.screen.addstr(y, x, c)

            else:

                self.screen.addch(y, x, c)

        except curses.error:

            pass

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

        for c in s:

            self.putch(x, y, c)

            x += 1

    def hline(self, x, y, w, c=' '):

        if type(c) is str:

            s = c*w

        else:

            s = [c]*w

        self.puts(x, y, s)

    def vline(self, x, y, h, c=' '):

        for i in range(h):

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

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

        self.putch(x, y, self.ULCORNER)

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

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

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

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

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

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

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

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

        for i in range(h):

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

    def erase(self):

        curses.curs_set(False)

        self.cursor = None

        self.screen.erase()

    def commit(self):

        if self.cursor:

            self.screen.move(*self.cursor)

            curses.curs_set(True)

        else:

            curses.curs_set(False)

        self.screen.refresh()

    ## cursor ##

    def showcursor(self, x, y):

        if not self.testclip(x, y):

            return

        self.cursor = (y, x)

    ## input ##

    def inputqueue_fill(self, timeout=None):

        if timeout is None:

            # wait indefinitely

            c = self.screen.getch()

            self.inputqueue.insert(0, c)

        elif timeout > 0:

            # wait

            curses.halfdelay(timeout)

            c = self.screen.getch()

            curses.cbreak()

            if c == -1:

                return

            self.inputqueue.insert(0, c)

        # timeout = 0 -> no wait

        self.screen.nodelay(1)

        while True:

            c = self.screen.getch()

            if c == -1:

                break

            self.inputqueue.insert(0, c)

        self.screen.nodelay(0)

    def inputqueue_top(self, num=0):

        return self.inputqueue[-1-num]

    def inputqueue_get(self):

        c = None

        try:

            c = self.inputqueue.pop()

        except IndexError:

            pass

        return c

    def inputqueue_get_wait(self):

        c = None

        while c is None:

            try:

                c = self.inputqueue.pop()

            except IndexError:

                curses.napms(25)

                self.inputqueue_fill(0)

        return c

    def inputqueue_unget(self, c):

        self.inputqueue.append(c)

    def process_input(self, timeout=None):

        # empty queue -> fill

        if len(self.inputqueue) == 0:

            self.inputqueue_fill(timeout)

        res = []

        while len(self.inputqueue):

            c = self.inputqueue_get()

            if c == curses.KEY_MOUSE:

                res += self.process_mouse()

            elif curses.ascii.isctrl(c):

                self.inputqueue_unget(c)

                res += self.process_control_chars()

            elif c >= 192 and c <= 255:

                self.inputqueue_unget(c)

                res += self.process_utf8_chars()

            elif curses.ascii.isprint(c):

                res += [('keypress', None, str(chr(c)))]

            else:

                #self.top.keypress(None, unicode(chr(c)))

                self.inputqueue_unget(c)

                res += self.process_control_chars()

        return res

    def process_mouse(self):

        ev = MouseEvent(x, y)

        out = []

        if bstate & curses.REPORT_MOUSE_POSITION:

            out += [('mousemove', ev)]

        if bstate & curses.BUTTON1_PRESSED:

            ev.button = 1

            out += [('mousedown', ev)]

        if bstate & curses.BUTTON3_PRESSED:

            ev.button = 3

            out += [('mousedown', ev)]

        if bstate & curses.BUTTON1_RELEASED:

            ev.button = 1

            out += [('mouseup', ev)]

        if bstate & curses.BUTTON3_RELEASED:

            ev.button = 3

            out += [('mouseup', ev)]

        return out

    def process_utf8_chars(self):

        #FIXME read exact number of chars as defined by utf-8

        utf = ''

        while len(utf) <= 6:

            c = self.inputqueue_get_wait()

            utf += chr(c)

            try:

                uni = str(utf, 'utf-8')

                return [('keypress', None, uni)]

            except UnicodeDecodeError:

                continue

        raise Exception('Invalid UTF-8 sequence: %r' % utf)

    def process_control_chars(self):

        codes = self.xterm_codes

        matchingcodes = []

        match = None

        consumed = []

        # consume next char, filter out matching codes

        c = self.inputqueue_get_wait()

        consumed.append(c)

        while True:

            self.log.debug('c=%s len=%s', c, len(codes))

            for code in codes:

                if c == code[len(consumed)-1]:

                    if len(code) - 1 == len(consumed):

                        match = code

                    else:

                        matchingcodes += [code]

            self.log.debug('matching=%s', len(matchingcodes))

            # match found, or no matching code found -> stop

            if len(matchingcodes) == 0:

                break

            # match found and some sequencies still match -> continue

            if len(matchingcodes) > 0:

                if len(self.inputqueue) == 0:

                    self.inputqueue_fill(1)

            c = self.inputqueue_get()

            if c:

                consumed.append(c)

                codes = matchingcodes

                matchingcodes = []

            else:

                break

        keyname = None

        if match:

            # compare match to consumed, return unused chars

            l = len(match) - 1

            while len(consumed) > l:

                self.inputqueue_unget(consumed[-1])

                del consumed[-1]

            keyname = match[-1]

        if match is None:

            self.log.debug('Unknown control sequence: %s',

                ','.join(['0x%x'%x for x in consumed]))

            return [('keypress', 'Unknown', None)]

        if keyname == 'mouse':

           return self.process_xterm_mouse()

        return [('keypress', keyname, None)]

    def process_xterm_mouse(self):

        t = self.inputqueue_get_wait()

        x = self.inputqueue_get_wait() - 0x21

        y = self.inputqueue_get_wait() - 0x21

        ev = MouseEvent(x, y)

        out = []

        if t in (0x20, 0x21, 0x22): # button press

            btn = t - 0x1f

            ev.button = btn

            if not btn in self.mbtnstack:

                self.mbtnstack.append(btn)

                out += [('mousedown', ev)]

            else:

                out += [('mousemove', ev)]

        elif t == 0x23: # button release

            ev.button = self.mbtnstack.pop()

            out += [('mouseup', ev)]

        elif t in (0x60, 0x61): # wheel up, down

            ev.button = 4 + t - 0x60

            out += [('mousewheel', ev)]

        else:

            raise Exception('Unknown mouse event: %x' % t)

        return out