##===-- cui.py -----------------------------------------------*- Python -*-===##
##
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
##
##===----------------------------------------------------------------------===##

import curses
import curses.ascii
import threading


class CursesWin(object):

    def __init__(self, x, y, w, h):
        self.win = curses.newwin(h, w, y, x)
        self.focus = False

    def setFocus(self, focus):
        self.focus = focus

    def getFocus(self):
        return self.focus

    def canFocus(self):
        return True

    def handleEvent(self, event):
        return

    def draw(self):
        return


class TextWin(CursesWin):

    def __init__(self, x, y, w):
        super(TextWin, self).__init__(x, y, w, 1)
        self.win.bkgd(curses.color_pair(1))
        self.text = ''
        self.reverse = False

    def canFocus(self):
        return False

    def draw(self):
        w = self.win.getmaxyx()[1]
        text = self.text
        if len(text) > w:
            #trunc_length = len(text) - w
            text = text[-w + 1:]
        if self.reverse:
            self.win.addstr(0, 0, text, curses.A_REVERSE)
        else:
            self.win.addstr(0, 0, text)
        self.win.noutrefresh()

    def setReverse(self, reverse):
        self.reverse = reverse

    def setText(self, text):
        self.text = text


class TitledWin(CursesWin):

    def __init__(self, x, y, w, h, title):
        super(TitledWin, self).__init__(x, y + 1, w, h - 1)
        self.title = title
        self.title_win = TextWin(x, y, w)
        self.title_win.setText(title)
        self.draw()

    def setTitle(self, title):
        self.title_win.setText(title)

    def draw(self):
        self.title_win.setReverse(self.getFocus())
        self.title_win.draw()
        self.win.noutrefresh()


class ListWin(CursesWin):

    def __init__(self, x, y, w, h):
        super(ListWin, self).__init__(x, y, w, h)
        self.items = []
        self.selected = 0
        self.first_drawn = 0
        self.win.leaveok(True)

    def draw(self):
        if len(self.items) == 0:
            self.win.erase()
            return

        h, w = self.win.getmaxyx()

        allLines = []
        firstSelected = -1
        lastSelected = -1
        for i, item in enumerate(self.items):
            lines = self.items[i].split('\n')
            lines = lines if lines[len(lines) - 1] != '' else lines[:-1]
            if len(lines) == 0:
                lines = ['']

            if i == self.getSelected():
                firstSelected = len(allLines)
            allLines.extend(lines)
            if i == self.selected:
                lastSelected = len(allLines) - 1

        if firstSelected < self.first_drawn:
            self.first_drawn = firstSelected
        elif lastSelected >= self.first_drawn + h:
            self.first_drawn = lastSelected - h + 1

        self.win.erase()

        begin = self.first_drawn
        end = begin + h

        y = 0
        for i, line in list(enumerate(allLines))[begin:end]:
            attr = curses.A_NORMAL
            if i >= firstSelected and i <= lastSelected:
                attr = curses.A_REVERSE
                line = '{0:{width}}'.format(line, width=w - 1)

            # Ignore the error we get from drawing over the bottom-right char.
            try:
                self.win.addstr(y, 0, line[:w], attr)
            except curses.error:
                pass
            y += 1
        self.win.noutrefresh()

    def getSelected(self):
        if self.items:
            return self.selected
        return -1

    def setSelected(self, selected):
        self.selected = selected
        if self.selected < 0:
            self.selected = 0
        elif self.selected >= len(self.items):
            self.selected = len(self.items) - 1

    def handleEvent(self, event):
        if isinstance(event, int):
            if len(self.items) > 0:
                if event == curses.KEY_UP:
                    self.setSelected(self.selected - 1)
                if event == curses.KEY_DOWN:
                    self.setSelected(self.selected + 1)
                if event == curses.ascii.NL:
                    self.handleSelect(self.selected)

    def addItem(self, item):
        self.items.append(item)

    def clearItems(self):
        self.items = []

    def handleSelect(self, index):
        return


class InputHandler(threading.Thread):

    def __init__(self, screen, queue):
        super(InputHandler, self).__init__()
        self.screen = screen
        self.queue = queue

    def run(self):
        while True:
            c = self.screen.getch()
            self.queue.put(c)


class CursesUI(object):
    """ Responsible for updating the console UI with curses. """

    def __init__(self, screen, event_queue):
        self.screen = screen
        self.event_queue = event_queue

        curses.start_color()
        curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
        curses.init_pair(2, curses.COLOR_YELLOW, curses.COLOR_BLACK)
        curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK)
        self.screen.bkgd(curses.color_pair(1))
        self.screen.clear()

        self.input_handler = InputHandler(self.screen, self.event_queue)
        self.input_handler.daemon = True

        self.focus = 0

        self.screen.refresh()

    def focusNext(self):
        self.wins[self.focus].setFocus(False)
        old = self.focus
        while True:
            self.focus += 1
            if self.focus >= len(self.wins):
                self.focus = 0
            if self.wins[self.focus].canFocus():
                break
        self.wins[self.focus].setFocus(True)

    def handleEvent(self, event):
        if isinstance(event, int):
            if event == curses.KEY_F3:
                self.focusNext()

    def eventLoop(self):

        self.input_handler.start()
        self.wins[self.focus].setFocus(True)

        while True:
            self.screen.noutrefresh()

            for i, win in enumerate(self.wins):
                if i != self.focus:
                    win.draw()
            # Draw the focused window last so that the cursor shows up.
            if self.wins:
                self.wins[self.focus].draw()
            curses.doupdate()  # redraw the physical screen

            event = self.event_queue.get()

            for win in self.wins:
                if isinstance(event, int):
                    if win.getFocus() or not win.canFocus():
                        win.handleEvent(event)
                else:
                    win.handleEvent(event)
            self.handleEvent(event)


class CursesEditLine(object):
    """ Embed an 'editline'-compatible prompt inside a CursesWin. """

    def __init__(self, win, history, enterCallback, tabCompleteCallback):
        self.win = win
        self.history = history
        self.enterCallback = enterCallback
        self.tabCompleteCallback = tabCompleteCallback

        self.prompt = ''
        self.content = ''
        self.index = 0
        self.startx = -1
        self.starty = -1

    def draw(self, prompt=None):
        if not prompt:
            prompt = self.prompt
        (h, w) = self.win.getmaxyx()
        if (len(prompt) + len(self.content)) / w + self.starty >= h - 1:
            self.win.scroll(1)
            self.starty -= 1
            if self.starty < 0:
                raise RuntimeError('Input too long; aborting')
        (y, x) = (self.starty, self.startx)

        self.win.move(y, x)
        self.win.clrtobot()
        self.win.addstr(y, x, prompt)
        remain = self.content
        self.win.addstr(remain[:w - len(prompt)])
        remain = remain[w - len(prompt):]
        while remain != '':
            y += 1
            self.win.addstr(y, 0, remain[:w])
            remain = remain[w:]

        length = self.index + len(prompt)
        self.win.move(self.starty + length / w, length % w)

    def showPrompt(self, y, x, prompt=None):
        self.content = ''
        self.index = 0
        self.startx = x
        self.starty = y
        self.draw(prompt)

    def handleEvent(self, event):
        if not isinstance(event, int):
            return  # not handled
        key = event

        if self.startx == -1:
            raise RuntimeError('Trying to handle input without prompt')

        if key == curses.ascii.NL:
            self.enterCallback(self.content)
        elif key == curses.ascii.TAB:
            self.tabCompleteCallback(self.content)
        elif curses.ascii.isprint(key):
            self.content = self.content[:self.index] + \
                chr(key) + self.content[self.index:]
            self.index += 1
        elif key == curses.KEY_BACKSPACE or key == curses.ascii.BS:
            if self.index > 0:
                self.index -= 1
                self.content = self.content[
                    :self.index] + self.content[self.index + 1:]
        elif key == curses.KEY_DC or key == curses.ascii.DEL or key == curses.ascii.EOT:
            self.content = self.content[
                :self.index] + self.content[self.index + 1:]
        elif key == curses.ascii.VT:  # CTRL-K
            self.content = self.content[:self.index]
        elif key == curses.KEY_LEFT or key == curses.ascii.STX:  # left or CTRL-B
            if self.index > 0:
                self.index -= 1
        elif key == curses.KEY_RIGHT or key == curses.ascii.ACK:  # right or CTRL-F
            if self.index < len(self.content):
                self.index += 1
        elif key == curses.ascii.SOH:  # CTRL-A
            self.index = 0
        elif key == curses.ascii.ENQ:  # CTRL-E
            self.index = len(self.content)
        elif key == curses.KEY_UP or key == curses.ascii.DLE:  # up or CTRL-P
            self.content = self.history.previous(self.content)
            self.index = len(self.content)
        elif key == curses.KEY_DOWN or key == curses.ascii.SO:  # down or CTRL-N
            self.content = self.history.next()
            self.index = len(self.content)
        self.draw()
