"""
Widget class definitions used by model_select.py, merge_diffusers.py and textual_inversion.py
"""
import curses
import math
import os
import platform
import pyperclip
import struct
import sys
import npyscreen
import textwrap
import npyscreen.wgmultiline as wgmultiline
from npyscreen import fmPopup
from shutil import get_terminal_size
from curses import BUTTON2_CLICKED,BUTTON3_CLICKED

# -------------------------------------
def set_terminal_size(columns: int, lines: int):
    OS = platform.uname().system
    if OS == "Windows":
        os.system(f"mode con: cols={columns} lines={lines}")
    elif OS in ["Darwin", "Linux"]:
        import fcntl
        import termios

        winsize = struct.pack("HHHH", lines, columns, 0, 0)
        fcntl.ioctl(sys.stdout.fileno(), termios.TIOCSWINSZ, winsize)
        sys.stdout.write("\x1b[8;{rows};{cols}t".format(rows=lines, cols=columns))
        sys.stdout.flush()


def set_min_terminal_size(min_cols: int, min_lines: int):
    # make sure there's enough room for the ui
    term_cols, term_lines = get_terminal_size()
    cols = max(term_cols, min_cols)
    lines = max(term_lines, min_lines)
    set_terminal_size(cols, lines)


class IntSlider(npyscreen.Slider):
    def translate_value(self):
        stri = "%2d / %2d" % (self.value, self.out_of)
        l = (len(str(self.out_of))) * 2 + 4
        stri = stri.rjust(l)
        return stri


# -------------------------------------
class CenteredTitleText(npyscreen.TitleText):
    def __init__(self, *args, **keywords):
        super().__init__(*args, **keywords)
        self.resize()

    def resize(self):
        super().resize()
        maxy, maxx = self.parent.curses_pad.getmaxyx()
        label = self.name
        self.relx = (maxx - len(label)) // 2


# -------------------------------------
class CenteredButtonPress(npyscreen.ButtonPress):
    def resize(self):
        super().resize()
        maxy, maxx = self.parent.curses_pad.getmaxyx()
        label = self.name
        self.relx = (maxx - len(label)) // 2


# -------------------------------------
class OffsetButtonPress(npyscreen.ButtonPress):
    def __init__(self, screen, offset=0, *args, **keywords):
        super().__init__(screen, *args, **keywords)
        self.offset = offset

    def resize(self):
        maxy, maxx = self.parent.curses_pad.getmaxyx()
        width = len(self.name)
        self.relx = self.offset + (maxx - width) // 2


class IntTitleSlider(npyscreen.TitleText):
    _entry_type = IntSlider


class FloatSlider(npyscreen.Slider):
    # this is supposed to adjust display precision, but doesn't
    def translate_value(self):
        stri = "%3.2f / %3.2f" % (self.value, self.out_of)
        l = (len(str(self.out_of))) * 2 + 4
        stri = stri.rjust(l)
        return stri


class FloatTitleSlider(npyscreen.TitleText):
    _entry_type = FloatSlider


class SelectColumnBase():
    def make_contained_widgets(self):
        self._my_widgets = []
        column_width = self.width // self.columns
        for h in range(self.value_cnt):
            self._my_widgets.append(
                self._contained_widgets(
                    self.parent,
                    rely=self.rely + (h % self.rows) * self._contained_widget_height,
                    relx=self.relx + (h // self.rows) * column_width,
                    max_width=column_width,
                    max_height=self.__class__._contained_widget_height,
                )
            )

    def set_up_handlers(self):
        super().set_up_handlers()
        self.handlers.update(
            {
                curses.KEY_UP: self.h_cursor_line_left,
                curses.KEY_DOWN: self.h_cursor_line_right,
            }
        )

    def h_cursor_line_down(self, ch):
        self.cursor_line += self.rows
        if self.cursor_line >= len(self.values):
            if self.scroll_exit:
                self.cursor_line = len(self.values) - self.rows
                self.h_exit_down(ch)
                return True
            else:
                self.cursor_line -= self.rows
                return True

    def h_cursor_line_up(self, ch):
        self.cursor_line -= self.rows
        if self.cursor_line < 0:
            if self.scroll_exit:
                self.cursor_line = 0
                self.h_exit_up(ch)
            else:
                self.cursor_line = 0

    def h_cursor_line_left(self, ch):
        super().h_cursor_line_up(ch)

    def h_cursor_line_right(self, ch):
        super().h_cursor_line_down(ch)

class MultiSelectColumns( SelectColumnBase, npyscreen.MultiSelect):
    def __init__(self, screen, columns: int = 1, values: list = [], **keywords):
        self.columns = columns
        self.value_cnt = len(values)
        self.rows = math.ceil(self.value_cnt / self.columns)
        super().__init__(screen, values=values, **keywords)

class SingleSelectWithChanged(npyscreen.SelectOne):
    def h_select(self,ch):
        super().h_select(ch)
        if self.on_changed:
            self.on_changed(self.value)

class SingleSelectColumns(SelectColumnBase, SingleSelectWithChanged):
    def __init__(self, screen, columns: int = 1, values: list = [], **keywords):
        self.columns = columns
        self.value_cnt = len(values)
        self.rows = math.ceil(self.value_cnt / self.columns)
        self.on_changed = None
        super().__init__(screen, values=values, **keywords)

    def when_value_edited(self):
        self.h_select(self.cursor_line)

    def when_cursor_moved(self):
        self.h_select(self.cursor_line)

    def h_cursor_line_right(self,ch):
        self.h_exit_down('bye bye')

class TextBox(npyscreen.MultiLineEdit):

    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        self.yank = None
        self.handlers.update({
            "^A": self.h_cursor_to_start,
            "^E": self.h_cursor_to_end,
            "^K": self.h_kill,
            "^F": self.h_cursor_right,
            "^B": self.h_cursor_left,
            "^Y": self.h_yank,
            "^V": self.h_paste,
        })

    def h_cursor_to_start(self, input):
        self.cursor_position = 0

    def h_cursor_to_end(self, input):
        self.cursor_position = len(self.value)

    def h_kill(self, input):
        self.yank = self.value[self.cursor_position:]
        self.value = self.value[:self.cursor_position]

    def h_yank(self, input):
        if self.yank:
            self.paste(self.yank)

    def paste(self, text: str):
        self.value = self.value[:self.cursor_position] + text + self.value[self.cursor_position:]
        self.cursor_position += len(text)

    def h_paste(self, input: int=0):
        try:
            text = pyperclip.paste()
        except ModuleNotFoundError:
            text = "To paste with the mouse on Linux, please install the 'xclip' program."
        self.paste(text)
        
    def handle_mouse_event(self, mouse_event):
        mouse_id, rel_x, rel_y, z, bstate = self.interpret_mouse_event(mouse_event)
        if bstate & (BUTTON2_CLICKED|BUTTON3_CLICKED):
            self.h_paste()

    def update(self, clear=True):
        if clear:
            self.clear()

        HEIGHT = self.height
        WIDTH = self.width
        # draw box.
        self.parent.curses_pad.hline(self.rely, self.relx, curses.ACS_HLINE, WIDTH)
        self.parent.curses_pad.hline(
            self.rely + HEIGHT, self.relx, curses.ACS_HLINE, WIDTH
        )
        self.parent.curses_pad.vline(
            self.rely, self.relx, curses.ACS_VLINE, self.height
        )
        self.parent.curses_pad.vline(
            self.rely, self.relx + WIDTH, curses.ACS_VLINE, HEIGHT
        )

        # draw corners
        self.parent.curses_pad.addch(
            self.rely,
            self.relx,
            curses.ACS_ULCORNER,
        )
        self.parent.curses_pad.addch(
            self.rely,
            self.relx + WIDTH,
            curses.ACS_URCORNER,
        )
        self.parent.curses_pad.addch(
            self.rely + HEIGHT,
            self.relx,
            curses.ACS_LLCORNER,
        )
        self.parent.curses_pad.addch(
            self.rely + HEIGHT,
            self.relx + WIDTH,
            curses.ACS_LRCORNER,
        )

        # fool our superclass into thinking drawing area is smaller - this is really hacky but it seems to work
        (relx, rely, height, width) = (self.relx, self.rely, self.height, self.width)
        self.relx += 1
        self.rely += 1
        self.height -= 1
        self.width -= 1
        super().update(clear=False)
        (self.relx, self.rely, self.height, self.width) = (relx, rely, height, width)

class BufferBox(npyscreen.BoxTitle):
    _contained_widget = npyscreen.BufferPager

class ConfirmCancelPopup(fmPopup.ActionPopup):
    DEFAULT_COLUMNS = 100
    def on_ok(self):
        self.value = True
    def on_cancel(self):
        self.value = False
        
class FileBox(npyscreen.BoxTitle):
    _contained_widget = npyscreen.Filename
    
def _wrap_message_lines(message, line_length):
    lines = []
    for line in message.split('\n'):
        lines.extend(textwrap.wrap(line.rstrip(), line_length))
    return lines
    
def _prepare_message(message):
    if isinstance(message, list) or isinstance(message, tuple):
        return "\n".join([ s.rstrip() for s in message])
        #return "\n".join(message)
    else:
        return message
    
def select_stable_diffusion_config_file(
        form_color: str='DANGER',
        wrap:bool =True,
        model_name:str='Unknown',
):
    message = "Please select the correct base model for the V2 checkpoint named {model_name}. Press <CANCEL> to skip installation."
    title = "CONFIG FILE SELECTION"
    options=[
        "An SD v2.x base model (512 pixels; no 'parameterization:' line in its yaml file)",
        "An SD v2.x v-predictive model (768 pixels; 'parameterization: \"v\"' line in its yaml file)",
        "Enter config file path manually",
    ]

    F = ConfirmCancelPopup(
        name=title,
        color=form_color,
        cycle_widgets=True,
        lines=16,
    )
    F.preserve_selected_widget = True
    
    mlw = F.add(
        wgmultiline.Pager,
        max_height=4,
        editable=False,
    )
    mlw_width = mlw.width-1
    if wrap:
        message = _wrap_message_lines(message, mlw_width)
    mlw.values = message

    choice = F.add(
        SingleSelectWithChanged,
        values = options,
        value = [0],
        max_height = len(options)+1,
        scroll_exit=True,
    )
    file = F.add(
        FileBox,
        name='Path to config file',
        max_height=3,
        hidden=True,
        must_exist=True,
        scroll_exit=True
    )

    def toggle_visible(value):
        value = value[0]
        if value==2:
            file.hidden=False
        else:
            file.hidden=True
        F.display()
        
    choice.on_changed = toggle_visible

    F.editw = 1
    F.edit()
    if not F.value:
        return None
    assert choice.value[0] in range(0,3),'invalid choice'
    choices = ['epsilon','v',file.value]
    return choices[choice.value[0]]