# -*- 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,                      'escape'        ),

        (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,0x31,0x7e,       'home'          ),  # linux

        (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,0x34,0x7e,       'end'           ),  # linux

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

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

        (0x1b,0x5b,0x41,            'up'            ),

        (0x1b,0x5b,0x42,            'down'          ),

        (0x1b,0x5b,0x43,            'right'         ),

        (0x1b,0x5b,0x44,            'left'          ),

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

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

        (0x1b,0x5b,0x4d,            'mouse'         ),

        (0x1b,0x5b,0x5b,0x41,       'f1'            ),  # linux

        (0x1b,0x5b,0x5b,0x42,       'f2'            ),  # linux

        (0x1b,0x5b,0x5b,0x43,       'f3'            ),  # linux

        (0x1b,0x5b,0x5b,0x44,       'f4'            ),  # linux

        (0x1b,0x5b,0x5b,0x45,       'f5'            ),  # linux

    )

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

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

        try:

            id, x, y, z, bstate = curses.getmouse()

        except curses.error:

            return []

        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