#
# libtui - TUI framework using ncurses
#  (c) 2024 Lunaixsky
# 
# I sware, this is the last time I ever touch 
#  any sort of the GUI messes.
#

import curses
import re
import curses.panel as cpanel
import curses.textpad as textpad
import textwrap

def __invoke_fn(obj, fn, *args):
    try:
        fn(*args)
    except:
        _id = obj._id if obj else "<root>"
        raise Exception(_id, str(fn), args)

def resize_safe(obj, co, y, x):
    __invoke_fn(obj, co.resize, y, x)

def move_safe(obj, co, y, x):
    __invoke_fn(obj, co.move, y, x)
    
def addstr_safe(obj, co, y, x, str, *args):
    __invoke_fn(obj, co.addstr, y, x, str, *args)

class _TuiColor:
    def __init__(self, v) -> None:
        self.__v = v
    def __int__(self):
        return self.__v
    def bright(self):
        return self.__v + 8

class TuiColor:
    black     = _TuiColor(curses.COLOR_BLACK)
    red       = _TuiColor(curses.COLOR_RED)
    green     = _TuiColor(curses.COLOR_GREEN)
    yellow    = _TuiColor(curses.COLOR_YELLOW)
    blue      = _TuiColor(curses.COLOR_BLUE)
    magenta   = _TuiColor(curses.COLOR_MAGENTA)
    cyan      = _TuiColor(curses.COLOR_CYAN)
    white     = _TuiColor(curses.COLOR_WHITE)

class Alignment:
    LEFT    = 0b000001
    RIGHT   = 0b000010
    CENTER  = 0b000100
    TOP     = 0b001000
    BOT     = 0b010000
    ABS     = 0b000000
    REL     = 0b100000

class ColorScope:
    WIN       = 1
    PANEL     = 2
    TEXT      = 3
    TEXT_HI   = 4
    SHADOW    = 5
    SELECT    = 6
    HINT      = 7
    BOX       = 8

class EventType:
    E_KEY = 0
    E_REDRAW = 1
    E_QUIT = 2
    E_TASK = 3
    E_CHFOCUS = 4
    E_M_FOCUS = 0b10000000

    def focused_only(t):
        return (t & EventType.E_M_FOCUS)
    
    def value(t):
        return t & ~EventType.E_M_FOCUS
    
    def key_press(t):
        return (t & ~EventType.E_M_FOCUS) == EventType.E_KEY

class Matchers:
    RelSize = re.compile(r"(?P<mult>[0-9]+(?:\.[0-9]+)?)?\*(?P<add>[+-][0-9]+)?")

class BoundExpression:
    def __init__(self, expr = None):
        self._mult = 0
        self._add  = 0

        if expr:
            self.update(expr)

    def set_pair(self, mult, add):
        self._mult = mult
        self._add  = add

    def set(self, expr):
        self._mult = expr._mult
        self._add  = expr._add
        
    def update(self, expr):
        if isinstance(expr, int):
            m = None
        else:
            m = Matchers.RelSize.match(expr)

        if m:
            g = m.groupdict()
            mult = 1 if not g["mult"] else float(g["mult"])
            add = 0 if not g["add"] else int(g["add"])
            self._mult = mult
            self._add  = add
        else:
            self.set_pair(0, int(expr))

    def calc(self, ref_val):
        return int(self._mult * ref_val + self._add)
    
    def absolute(self):
        return self._mult == 0
    
    def nullity(self):
        return self._mult == 0 and self._add == 0
    
    def scale_mult(self, scalar):
        self._mult *= scalar
        return self
    
    @staticmethod
    def normalise(*exprs):
        v = BoundExpression()
        for e in exprs:
            v += e
        return [e.scale_mult(1 / v._mult) for e in exprs]

    def __add__(self, b):
        v = BoundExpression()
        v.set(self)
        v._mult += b._mult
        v._add  += b._add
        return v

    def __sub__(self, b):
        v = BoundExpression()
        v.set(self)
        v._mult -= b._mult
        v._add  -= b._add
        return v
    
    def __iadd__(self, b):
        self._mult += b._mult
        self._add  += b._add
        return self

    def __isub__(self, b):
        self._mult -= b._mult
        self._add  -= b._add
        return self
    
    def __rmul__(self, scalar):
        v = BoundExpression()
        v.set(self)
        v._mult *= scalar
        v._add *= scalar
        return v

    def __truediv__(self, scalar):
        v = BoundExpression()
        v.set(self)
        v._mult /= float(scalar)
        v._add /= scalar
        return v
    
class DynamicBound:
    def __init__(self):
        self.__x = BoundExpression()
        self.__y = BoundExpression()
    
    def dyn_x(self):
        return self.__x

    def dyn_y(self):
        return self.__y
    
    def resolve(self, ref_w, ref_h):
        return (self.__y.calc(ref_h), self.__x.calc(ref_w))
    
    def set(self, dyn_bound):
        self.__x.set(dyn_bound.dyn_x())
        self.__y.set(dyn_bound.dyn_y())

class Bound:
    def __init__(self) -> None:
        self.__x = 0
        self.__y = 0

    def shrinkX(self, dx):
        self.__x -= dx
    def shrinkY(self, dy):
        self.__y -= dy

    def growX(self, dx):
        self.__x += dx
    def growY(self, dy):
        self.__y += dy

    def resetX(self, x):
        self.__x = x
    def resetY(self, y):
        self.__y = y

    def update(self, dynsz, ref_bound):
        y, x = dynsz.resolve(ref_bound.x(), ref_bound.y())
        self.__x = x
        self.__y = y

    def reset(self, x, y):
        self.__x, self.__y = x, y

    def x(self):
        return self.__x
    
    def y(self):
        return self.__y
    
    def yx(self, scale = 1):
        return int(self.__y * scale), int(self.__x * scale)

class TuiStackWindow:
    def __init__(self, obj) -> None:
        self.__obj = obj
        self.__win = curses.newwin(0, 0)
        self.__pan = cpanel.new_panel(self.__win)
        self.__pan.hide()

    def resize(self, h, w):
        resize_safe(self.__obj, self.__win, h, w)
    
    def relocate(self, y, x):
        move_safe(self.__obj, self.__pan, y, x)

    def set_geometric(self, h, w, y, x):
        resize_safe(self.__obj, self.__win, h, w)
        move_safe(self.__obj, self.__pan, y, x)

    def set_background(self, color_scope):
        self.__win.bkgd(' ', curses.color_pair(color_scope))

    def show(self):
        self.__pan.show()

    def hide(self):
        self.__pan.hide()
    
    def send_back(self):
        self.__pan.bottom()

    def send_front(self):
        self.__pan.top()

    def window(self):
        return self.__win

class SpatialObject:
    def __init__(self) -> None:
        self._local_pos = DynamicBound()
        self._pos = Bound()
        self._dyn_size = DynamicBound()
        self._size = Bound()
        self._margin = (0, 0, 0, 0)
        self._padding = (0, 0, 0, 0)
        self._align = Alignment.TOP | Alignment.LEFT

    def set_local_pos(self, x, y):
        self._local_pos.dyn_x().update(x)
        self._local_pos.dyn_y().update(y)

    def set_alignment(self, align):
        self._align = align

    def set_size(self, w = None, h = None):
        if w:
            self._dyn_size.dyn_x().update(w)
        if h:
            self._dyn_size.dyn_y().update(h)

    def set_margin(self, top, right, bottom, left):
        self._margin = (top, right, bottom, left)

    def set_padding(self, top, right, bottom, left):
        self._padding = (top, right, bottom, left)

    def reset(self):
        self._pos.reset(0, 0)
        self._size.reset(0, 0)

    def deduce_spatial(self, constrain):
        self.reset()
        self.__satisfy_bound(constrain)
        self.__satisfy_alignment(constrain)
        self.__satisfy_margin(constrain)
        self.__satisfy_padding(constrain)

        self.__to_corner_pos(constrain)

    def __satisfy_alignment(self, constrain):
        local_pos = self._local_pos
        cbound = constrain._size
        size = self._size

        cy, cx = cbound.yx()
        ry, rx = local_pos.resolve(cx, cy)
        ay, ax = size.yx(0.5)
        
        if self._align & Alignment.CENTER:
            ax = cx // 2
            ay = cy // 2
        
        if self._align & Alignment.BOT:
            ay = min(cy - ay, cy - 1)
            ry = -ry
        elif self._align & Alignment.TOP:
            ay = size.y() // 2

        if self._align & Alignment.RIGHT:
            ax = cx - ax
            rx = -rx
        elif self._align & Alignment.LEFT:
            ax = size.x() // 2

        self._pos.reset(ax + rx, ay + ry)

    def __satisfy_margin(self, constrain):
        tm, lm, bm, rm = self._margin
        
        self._pos.growX(rm - lm)
        self._pos.growY(bm - tm)

    def __satisfy_padding(self, constrain):
        csize = constrain._size
        ch, cw = csize.yx()
        h, w = self._size.yx(0.5)
        y, x = self._pos.yx()

        tp, lp, bp, rp = self._padding

        if not (tp or lp or bp or rp):
            return

        dtp = min(y - h, tp) - tp
        dbp = min(ch - (y + h), bp) - bp

        dlp = min(x - w, lp) - lp
        drp = min(cw - (x + w), rp) - rp

        self._size.growX(drp + dlp)
        self._size.growY(dtp + dbp)

    def __satisfy_bound(self, constrain):
        self._size.update(self._dyn_size, constrain._size)

    def __to_corner_pos(self, constrain):
        h, w = self._size.yx(0.5)
        g_pos = constrain._pos

        self._pos.shrinkX(w)
        self._pos.shrinkY(h)

        self._pos.growX(g_pos.x())
        self._pos.growY(g_pos.y())
        

class TuiObject(SpatialObject):
    def __init__(self, context, id):
        super().__init__()
        self._id = id
        self._context = context
        self._parent = None
        self._visible = True
        self._focused = False

    def set_parent(self, parent):
        self._parent = parent

    def canvas(self):
        if self._parent:
            return self._parent.canvas()
        return (self, self._context.window())
    
    def context(self):
        return self._context
    
    def session(self):
        return self._context.session()

    def on_create(self):
        pass

    def on_destory(self):
        pass

    def on_quit(self):
        pass

    def on_layout(self):
        if self._parent:
            self.deduce_spatial(self._parent)

    def on_draw(self):
        pass

    def on_event(self, ev_type, ev_arg):
        pass

    def on_focused(self):
        self._focused = True

    def on_focus_lost(self):
        self._focused = False

    def set_visbility(self, visible):
        self._visible = visible

    def do_draw(self):
        if self._visible:
            self.on_draw()
    
    def do_layout(self):
        self.on_layout()

class TuiWidget(TuiObject):
    def __init__(self, context, id):
        super().__init__(context, id)
    
    def on_layout(self):
        super().on_layout()
        
        co, _ = self.canvas()

        y, x = co._pos.yx()
        self._pos.shrinkX(x)
        self._pos.shrinkY(y)

class TuiContainerObject(TuiObject):
    def __init__(self, context, id):
        super().__init__(context, id)
        self._children = []

    def add(self, child):
        child.set_parent(self)
        self._children.append(child)

    def children(self):
        return self._children

    def on_create(self):
        super().on_create()
        for child in self._children:
            child.on_create()

    def on_destory(self):
        super().on_destory()
        for child in self._children:
            child.on_destory()
    
    def on_quit(self):
        super().on_quit()
        for child in self._children:
            child.on_quit()

    def on_layout(self):
        super().on_layout()
        for child in self._children:
            child.do_layout()

    def on_draw(self):
        super().on_draw()
        for child in self._children:
            child.do_draw()

    def on_event(self, ev_type, ev_arg):
        super().on_event(ev_type, ev_arg)
        for child in self._children:
            child.on_event(ev_type, ev_arg)


class TuiScrollable(TuiObject):
    def __init__(self, context, id):
        super().__init__(context, id)
        self.__spos = Bound()

        self.__pad = curses.newpad(1, 1)
        self.__pad.bkgd(' ', curses.color_pair(ColorScope.PANEL))
        self.__pad_panel = cpanel.new_panel(self.__pad)
        self.__content = None

    def canvas(self):
        return (self, self.__pad)

    def set_content(self, content):
        self.__content = content
        self.__content.set_parent(self)

    def set_scrollY(self, y):
        self.__spos.resetY(y)

    def set_scrollX(self, x):
        self.__spos.resetX(x)

    def reached_last(self):
        off = self.__spos.y() + self._size.y()
        return off >= self.__content._size.y()
    
    def reached_top(self):
        return self.__spos.y() < self._size.y()

    def on_layout(self):
        super().on_layout()

        if not self.__content:
            return
        
        self.__content.on_layout()
                
        h, w = self._size.yx()
        ch, cw = self.__content._size.yx()
        sh, sw = max(ch, h), max(cw, w)

        self.__spos.resetX(min(self.__spos.x(), max(cw, w) - w))
        self.__spos.resetY(min(self.__spos.y(), max(ch, h) - h))

        resize_safe(self, self.__pad, sh, sw)

    def on_draw(self):
        if not self.__content:
            return
        
        self.__pad.erase()

        self.__pad_panel.top()
        self.__content.on_draw()

        wminy, wminx = self._pos.yx()
        wmaxy, wmaxx = self._size.yx()
        wmaxy, wmaxx = wmaxy + wminy, wmaxx + wminx
        self.__pad.touchwin()
        self.__pad.refresh(*self.__spos.yx(), 
                            wminy, wminx, wmaxy - 1, wmaxx - 1)


class Layout(TuiContainerObject):
    class Cell(TuiObject):
        def __init__(self, context):
            super().__init__(context, "cell")
            self.__obj = None

        def set_obj(self, obj):
            self.__obj = obj
            self.__obj.set_parent(self)

        def on_create(self):
            if self.__obj:
                self.__obj.on_create()

        def on_destory(self):
            if self.__obj:
                self.__obj.on_destory()

        def on_quit(self):
            if self.__obj:
                self.__obj.on_quit()

        def on_layout(self):
            super().on_layout()
            if self.__obj:
                self.__obj.do_layout()

        def on_draw(self):
            if self.__obj:
                self.__obj.do_draw()

        def on_event(self, ev_type, ev_arg):
            if self.__obj:
                self.__obj.on_event(ev_type, ev_arg)
    
    def __init__(self, context, id, ratios):
        super().__init__(context, id)

        rs = [BoundExpression(r) for r in ratios.split(',')]
        self._rs = BoundExpression.normalise(*rs)

        for _ in range(len(self._rs)):
            cell = Layout.Cell(self._context)
            super().add(cell)

        self._adjust_to_fit()

    def _adjust_to_fit(self):
        pass

    def add(self, child):
        raise RuntimeError("invalid operation")
    
    def set_cell(self, i, obj):
        if i > len(self._children):
            raise ValueError(f"cell #{i} out of bound")
        
        self._children[i].set_obj(obj)


class FlexLinearLayout(Layout):
    LANDSCAPE = 0
    PORTRAIT = 1
    def __init__(self, context, id, ratios):
        self.__horizontal = False

        super().__init__(context, id, ratios)

    def orientation(self, orient):
        self.__horizontal = orient == FlexLinearLayout.LANDSCAPE
    
    def on_layout(self):
        self.__apply_ratio()
        super().on_layout()
    
    def _adjust_to_fit(self):
        sum_abs = BoundExpression()
        i = 0
        for r in self._rs:
            if r.absolute():
                sum_abs += r
            else:
                i += 1

        sum_abs /= i
        for i, r in enumerate(self._rs):
            if not r.absolute():
                self._rs[i] -= sum_abs

    def __apply_ratio(self):
        if self.__horizontal:
            self.__adjust_horizontal()
        else:
            self.__adjust_vertical()
        
    def __adjust_horizontal(self):
        acc = BoundExpression()
        for r, cell in zip(self._rs, self.children()):
            cell._dyn_size.dyn_y().set_pair(1, 0)
            cell._dyn_size.dyn_x().set(r)

            cell.set_alignment(Alignment.LEFT)
            cell._local_pos.dyn_y().set_pair(0, 0)
            cell._local_pos.dyn_x().set(acc)

            acc += r

    def __adjust_vertical(self):
        acc = BoundExpression()
        for r, cell in zip(self._rs, self.children()):
            cell._dyn_size.dyn_x().set_pair(1, 0)
            cell._dyn_size.dyn_y().set(r)

            cell.set_alignment(Alignment.TOP | Alignment.CENTER)
            cell._local_pos.dyn_x().set_pair(0, 0)
            cell._local_pos.dyn_y().set(acc)

            acc += r


class TuiPanel(TuiContainerObject):
    def __init__(self, context, id):
        super().__init__(context, id)

        self.__use_border = False
        self.__use_shadow = False
        self.__shadow_param = (0, 0)

        self.__swin = TuiStackWindow(self)
        self.__shad = TuiStackWindow(self)

        self.__swin.set_background(ColorScope.PANEL)
        self.__shad.set_background(ColorScope.SHADOW)

    def canvas(self):
        return (self, self.__swin.window())

    def drop_shadow(self, off_y, off_x):
        self.__shadow_param = (off_y, off_x)
        self.__use_shadow = not (off_y == off_x and off_y == 0)

    def border(self, _b):
        self.__use_border = _b

    def bkgd_override(self, scope):
        self.__swin.set_background(scope)

    def on_layout(self):
        super().on_layout()

        self.__swin.hide()

        h, w = self._size.y(), self._size.x()
        y, x = self._pos.y(), self._pos.x()
        self.__swin.set_geometric(h, w, y, x)
        
        if self.__use_shadow:
            sy, sx = self.__shadow_param
            self.__shad.set_geometric(h, w, y + sy, x + sx)

    def on_destory(self):
        super().on_destory()
        self.__swin.hide()
        self.__shad.hide()

    def on_draw(self):
        win = self.__swin.window()
        win.erase()

        if self.__use_border:
            win.border()
        
        if self.__use_shadow:
            self.__shad.show()
        else:
            self.__shad.hide()

        self.__swin.show()
        self.__swin.send_front()

        super().on_draw()

        win.touchwin()

class TuiLabel(TuiWidget):
    def __init__(self, context, id):
        super().__init__(context, id)
        self._text = "TuiLabel"
        self._wrapped = []

        self.__auto_fit = True
        self.__trunc = False
        self.__dopad = False
        self.__highlight = False
        self.__color_scope = -1

    def __try_fit_text(self, txt):
        if self.__auto_fit:
            self._dyn_size.dyn_x().set_pair(0, len(txt))
            self._dyn_size.dyn_y().set_pair(0, 1)

    def __pad_text(self):
        for i, t in enumerate(self._wrapped):
            self._wrapped[i] = str.rjust(t, self._size.x())
    
    def set_text(self, text):
        self._text = text
        self.__try_fit_text(text)

    def override_color(self, color = -1):
        self.__color_scope = color

    def auto_fit(self, _b):
        self.__auto_fit = _b

    def truncate(self, _b):
        self.__trunc = _b

    def hightlight(self, _b):
        self.__highlight = _b

    def pad_around(self, _b):
        self.__dopad = _b

    def on_layout(self):
        txt = self._text
        if self.__dopad:
            txt = f" {txt} "
            self.__try_fit_text(txt)
        
        super().on_layout()

        if len(txt) <= self._size.x():
            self._wrapped = [txt]
            self.__pad_text()
            return

        if not self.__trunc:
            txt = txt[:self._size.x() - 1]
            self._wrapped = [txt]
            self.__pad_text()
            return

        self._wrapped = textwrap.wrap(txt, self._size.x())
        self.__pad_text()

    def on_draw(self):
        _, win = self.canvas()
        y, x = self._pos.yx()
        
        if self.__color_scope != -1:
            color = curses.color_pair(self.__color_scope)
        elif self.__highlight:
            color = curses.color_pair(ColorScope.TEXT_HI)
        else:
            color = curses.color_pair(ColorScope.TEXT)

        for i, t in enumerate(self._wrapped):
            addstr_safe(self, win, y + i, x, t, color)


class TuiTextBlock(TuiWidget):
    def __init__(self, context, id):
        super().__init__(context, id)
        self.__lines = []
        self.__wrapped = []
        self.__fit_to_height = False
    
    def set_text(self, text):
        text = textwrap.dedent(text)
        self.__lines = text.split('\n')
        if self.__fit_to_height:
            self._dyn_size.dyn_y().set_pair(0, 0)

    def height_auto_fit(self, yes):
        self.__fit_to_height = yes

    def on_layout(self):
        super().on_layout()

        self.__wrapped.clear()
        for t in self.__lines:
            if not t:
                self.__wrapped.append(t)
                continue
            wrap = textwrap.wrap(t, self._size.x())
            self.__wrapped += wrap

        if self._dyn_size.dyn_y().nullity():
            h = len(self.__wrapped)
            self._dyn_size.dyn_y().set_pair(0, h)

            # redo layouting
            super().on_layout()

    def on_draw(self):
        _, win = self.canvas()
        y, x = self._pos.yx()
        
        color = curses.color_pair(ColorScope.TEXT)
        for i, t in enumerate(self.__wrapped):
            addstr_safe(self, win, y + i, x, t, color)


class TuiTextBox(TuiWidget):
    def __init__(self, context, id):
        super().__init__(context, id)
        self.__box = TuiStackWindow(self)
        self.__box.set_background(ColorScope.PANEL)
        self.__textb = textpad.Textbox(self.__box.window(), True)
        self.__textb.stripspaces = True
        self.__str = ""
        self.__scheduled_edit = False

        self._context.focus_group().register(self, 0)

    def __validate(self, x):
        if x == 10 or x == 9:
            return 7
        return x
    
    def on_layout(self):
        super().on_layout()

        co, _ = self.canvas()
        h, w = self._size.yx()
        y, x = self._pos.yx()
        cy, cx = co._pos.yx()
        y, x = y + cy, x + cx

        self.__box.hide()
        self.__box.set_geometric(1, w - 1, y + h // 2, x + 1)

    def on_draw(self):
        self.__box.show()
        self.__box.send_front()
        
        _, cwin = self.canvas()

        h, w = self._size.yx()
        y, x = self._pos.yx()
        textpad.rectangle(cwin, y, x, y + h - 1, x+w)

        win = self.__box.window()
        win.touchwin()

    def __edit(self):
        self.__str = self.__textb.edit(lambda x: self.__validate(x))
        self.session().schedule(EventType.E_CHFOCUS)
        self.__scheduled_edit = False

    def get_text(self):
        return self.__str
    
    def on_focused(self):
        self.__box.set_background(ColorScope.BOX)
        if not self.__scheduled_edit:
            # edit will block, defer to next update cycle
            self.session().schedule_task(self.__edit)
            self.__scheduled_edit = True

    def on_focus_lost(self):
        self.__box.set_background(ColorScope.PANEL)
        

class SimpleList(TuiWidget):
    class Item:
        def __init__(self) -> None:
            pass
        def get_text(self):
            return "list_item"
        def on_selected(self):
            pass
        def on_key_pressed(self, key):
            pass

    def __init__(self, context, id):
        super().__init__(context, id)
        self.__items = []
        self.__selected = 0
        self.__on_sel_confirm_cb = None
        self.__on_sel_change_cb = None

        self._context.focus_group().register(self)

    def set_onselected_cb(self, cb):
        self.__on_sel_confirm_cb = cb

    def set_onselection_change_cb(self, cb):
        self.__on_sel_change_cb = cb

    def count(self):
        return len(self.__items)
    
    def index(self):
        return self.__selected

    def add_item(self, item):
        self.__items.append(item)

    def clear(self):
        self.__items.clear()

    def on_layout(self):
        super().on_layout()
        self.__selected = min(self.__selected, len(self.__items))
        self._size.resetY(len(self.__items) + 1)

    def on_draw(self):
        _, win = self.canvas()
        w = self._size.x()

        for i, item in enumerate(self.__items):
            color = curses.color_pair(ColorScope.TEXT)
            if i == self.__selected:
                if self._focused:
                    color = curses.color_pair(ColorScope.SELECT)
                else:
                    color = curses.color_pair(ColorScope.BOX)
            
            txt = str.ljust(item.get_text(), w)
            txt = txt[:w]
            addstr_safe(self, win, i, 0, txt, color)

    def on_event(self, ev_type, ev_arg):
        if not EventType.key_press(ev_type):
            return
        
        if len(self.__items) == 0:
            return

        sel = self.__items[self.__selected]

        if ev_arg == 10:
            sel.on_selected()
            
            if self.__on_sel_confirm_cb:
                self.__on_sel_confirm_cb(self, self.__selected, sel)
            return
        
        sel.on_key_pressed(ev_arg)
        
        if (ev_arg != curses.KEY_DOWN and 
            ev_arg != curses.KEY_UP):
            return

        prev = self.__selected
        if ev_arg == curses.KEY_DOWN:
            self.__selected += 1
        else:
            self.__selected -= 1

        self.__selected = max(self.__selected, 0)
        self.__selected = self.__selected % len(self.__items)
        
        if self.__on_sel_change_cb:
            self.__on_sel_change_cb(self, prev, self.__selected)


class TuiButton(TuiLabel):
    def __init__(self, context, id):
        super().__init__(context, id)
        self.__onclick = None

        context.focus_group().register(self)

    def set_text(self, text):
        return super().set_text(f"<{text}>")

    def set_click_callback(self, cb):
        self.__onclick = cb

    def hightlight(self, _b):
        raise NotImplemented()
    
    def on_draw(self):
        _, win = self.canvas()
        y, x = self._pos.yx()
        
        if self._focused:
            color = curses.color_pair(ColorScope.SELECT)
        else:
            color = curses.color_pair(ColorScope.TEXT)

        addstr_safe(self, win, y, x, self._wrapped[0], color)
    
    def on_event(self, ev_type, ev_arg):
        if not EventType.focused_only(ev_type):
            return
        if not EventType.key_press(ev_type):
            return
        
        if ev_arg == ord('\n') and self.__onclick:
            self.__onclick(self)


class TuiSession:
    def __init__(self) -> None:
        self.stdsc = curses.initscr()
        curses.start_color()

        curses.noecho()
        curses.cbreak()

        self.__context_stack = []
        self.__sched_events = []

        ws = self.window_size()
        self.__win = curses.newwin(*ws)
        self.__winbg = curses.newwin(*ws)
        self.__panbg = cpanel.new_panel(self.__winbg)

        self.__winbg.bkgd(' ', curses.color_pair(ColorScope.WIN))

        self.__win.timeout(50)
        self.__win.keypad(True)

    def window_size(self):
        return self.stdsc.getmaxyx()

    def set_color(self, scope, fg, bg):
        curses.init_pair(scope, int(fg), int(bg))

    def schedule_redraw(self):
        self.schedule(EventType.E_REDRAW)

    def schedule_task(self, task):
        self.schedule(EventType.E_REDRAW)
        self.schedule(EventType.E_TASK, task)

    def schedule(self, event, arg = None):
        if len(self.__sched_events) > 0:
            if self.__sched_events[-1] == event:
                return
    
        self.__sched_events.append((event, arg))

    def push_context(self, tuictx):
        tuictx.prepare()
        self.__context_stack.append(tuictx)
        self.schedule(EventType.E_REDRAW)

        curses.curs_set(self.active().curser_mode())

    def pop_context(self):
        if len(self.__context_stack) == 1:
            return
        
        ctx = self.__context_stack.pop()
        ctx.on_destory()
        self.schedule(EventType.E_REDRAW)

        curses.curs_set(self.active().curser_mode())

    def active(self):
        return self.__context_stack[-1]
    
    def event_loop(self):
        if len(self.__context_stack) == 0:
            raise RuntimeError("no tui context to display")
        
        while True:
            key = self.__win.getch()
            if key != -1:
                self.schedule(EventType.E_KEY, key)
            
            if len(self.__sched_events) == 0:
                continue

            evt, arg = self.__sched_events.pop(0)
            if evt == EventType.E_REDRAW:
                self.__redraw()
            elif evt == EventType.E_QUIT:
                self.__notify_quit()
                break

            self.active().dispatch_event(evt, arg)
        
    def __notify_quit(self):
        while len(self.__context_stack) == 0:
            ctx = self.__context_stack.pop()
            ctx.dispatch_event(EventType.E_QUIT, None)

    def __redraw(self):
        self.stdsc.erase()
        self.__win.erase()
        
        self.active().redraw(self.__win)

        self.__panbg.bottom()
        self.__win.touchwin()
        self.__winbg.touchwin()

        self.__win.refresh()
        self.__winbg.refresh()

        cpanel.update_panels()
        curses.doupdate()

class TuiFocusGroup:
    def __init__(self) -> None:
        self.__grp = []
        self.__id = 0
        self.__sel = 0
        self.__focused = None
    
    def register(self, tui_obj, pos=-1):
        if pos == -1:
            self.__grp.append((self.__id, tui_obj))
        else:
            self.__grp.insert(pos, (self.__id, tui_obj))
        self.__id += 1
        return self.__id - 1

    def navigate_focus(self, dir = 1):
        self.__sel = (self.__sel + dir) % len(self.__grp)
        f = None if not len(self.__grp) else self.__grp[self.__sel][1]
        if f and f != self.__focused:
            if self.__focused:
                self.__focused.on_focus_lost()
            f.on_focused()
        self.__focused = f

    def focused(self):
        return self.__focused

class TuiContext(TuiObject):
    def __init__(self, session: TuiSession):
        super().__init__(self, "context")
        self.__root = None
        self.__sobj = None
        self.__session = session

        self.__win = None

        y, x = self.__session.window_size()
        self._size.reset(x, y)
        self.set_parent(None)

        self.__focus_group = TuiFocusGroup()
        self.__curser_mode = 0

    def set_curser_mode(self, mode):
        self.__curser_mode = mode

    def curser_mode(self):
        return self.__curser_mode

    def set_root(self, root):
        self.__root = root
        self.__root.set_parent(self)
    
    def set_state(self, obj):
        self.__sobj = obj

    def state(self):
        return self.__sobj

    def prepare(self):
        self.__root.on_create()

    def on_destory(self):
        self.__root.on_destory()

    def canvas(self):
        return (self, self.__win)
    
    def session(self):
        return self.__session
    
    def dispatch_event(self, evt, arg):
        if evt == EventType.E_REDRAW:
            self.__focus_group.navigate_focus(0)
        elif evt == EventType.E_CHFOCUS:
            self.__focus_group.navigate_focus(1)
            self.__session.schedule(EventType.E_REDRAW)
            return
        elif evt == EventType.E_TASK:
            arg()
        elif evt == EventType.E_QUIT:
            self.__root.on_quit()
        elif evt == EventType.E_KEY:
            self._handle_key_event(arg)
        else:
            self.__root.on_event(evt, arg)

        focused = self.__focus_group.focused()
        if focused:
            focused.on_event(evt | EventType.E_M_FOCUS, arg)

    def redraw(self, win):
        self.__win = win
        self.on_layout()
        self.on_draw()

    def on_layout(self):
        self.__root.on_layout()

    def on_draw(self):
        self.__root.on_draw()

    def focus_group(self):
        return self.__focus_group
    
    def _handle_key_event(self, key):
        if key == ord('\t') or key == curses.KEY_RIGHT:
            self.__focus_group.navigate_focus()
        elif key == curses.KEY_LEFT:
            self.__focus_group.navigate_focus(-1)
        else:
            self.__root.on_event(EventType.E_KEY, key)
        
        if self.__focus_group.focused():
            self.__session.schedule(EventType.E_REDRAW)