# Adapted for card10 by hirnsalat. License for original code below.
# For more info (and converting additional fonts), see:
# https://github.com/peterhinch/micropython-font-to-py

# writer.py Implements the Writer class.
# Handles colour, word wrap and tab stops

# V0.4.3 Aug 2021 Support for fast blit to color displays (PR7682).
# V0.4.0 Jan 2021 Improved handling of word wrap and line clip. Upside-down
# rendering no longer supported: delegate to device driver.
# V0.3.5 Sept 2020 Fast rendering option for color displays

# Released under the MIT License (MIT). See LICENSE.
# Copyright (c) 2019-2021 Peter Hinch

# A Writer supports rendering text to a Display instance in a given font.
# Multiple Writer instances may be created, each rendering a font to the
# same Display object.

# Timings based on a 20 pixel high proportional font, run on a pyboard V1.0.
# Using CWriter's slow rendering: _printchar 9.5ms typ, 13.5ms max.


import framebuf
#from uctypes import bytearray_at, addressof
from sys import implementation
import os
import display as card10_display

class DisplayState():
    def __init__(self):
        self.text_row = 0
        self.text_col = 0

def _get_id(device):
    if not isinstance(device, framebuf.FrameBuffer):
        raise ValueError('Device must be derived from FrameBuffer.')
    return id(device)

# Basic Writer class for monochrome displays
class Writer():

    state = {}  # Holds a display state for each device

    @staticmethod
    def set_textpos(device, row=None, col=None):
        devid = _get_id(device)
        if devid not in Writer.state:
            Writer.state[devid] = DisplayState()
        s = Writer.state[devid]  # Current state
        if row is not None:
            if row < 0 or row >= 20:
                raise ValueError('row is out of range')
            s.text_row = row
        if col is not None:
            if col < 0 or col >= 160:
                raise ValueError('col is out of range')
            s.text_col = col
        return s.text_row,  s.text_col

    def __init__(self, device, width, height, font, verbose=True):
        self.devid = _get_id(device)
        self.device = device
        if self.devid not in Writer.state:
            Writer.state[self.devid] = DisplayState()
        self.font = font
        # Allow to work with reverse or normal font mapping
        if font.hmap():
            self.map = framebuf.MONO_HMSB if font.reverse() else framebuf.MONO_HLSB
        else:
            raise ValueError('Font must be horizontally mapped.')
        if verbose:
            print('Start row = {} col = {}'.format(self._getstate().text_row, self._getstate().text_col))
        self.screenwidth = width
        self.screenheight = height
        self.bgcolor = 0  # Monochrome background and foreground colors
        self.fgcolor = 1
        self.row_clip = False  # Clip or scroll when screen fullt
        self.col_clip = False  # Clip or new line when row is full
        self.wrap = True  # Word wrap
        self.cpos = 0
        self.tab = 4

        self.glyph = None  # Current char
        self.char_height = 0
        self.char_width = 0
        self.clip_width = 0

    def _getstate(self):
        return Writer.state[self.devid]

    def _newline(self):
        s = self._getstate()
        height = self.font.height()
        s.text_row += height
        s.text_col = 0
        margin = self.screenheight - (s.text_row + height)
        y = self.screenheight + margin
        if margin < 0:
            if not self.row_clip:
                self.device.scroll(0, margin)
                self.device.fill_rect(0, y, self.screenwidth, abs(margin), self.bgcolor)
                s.text_row += margin

    def set_clip(self, row_clip=None, col_clip=None, wrap=None):
        if row_clip is not None:
            self.row_clip = row_clip
        if col_clip is not None:
            self.col_clip = col_clip
        if wrap is not None:
            self.wrap = wrap
        return self.row_clip, self.col_clip, self.wrap

    @property
    def height(self):  # Property for consistency with device
        return self.font.height()

    def printstring(self, string, invert=False):
        # word wrapping. Assumes words separated by single space.
        q = string.split('\n')
        last = len(q) - 1
        for n, s in enumerate(q):
            if s:
                self._printline(s, invert)
            if n != last:
                self._printchar('\n')

    def _printline(self, string, invert):
        rstr = None
        if self.wrap:
            pos = self._splitpoint(string)
            if pos < len(string):
                rstr = string[pos:]
                string = string[:pos].rstrip()
                
        for char in string:
            self._printchar(char, invert)
        if rstr is not None:
            self._printchar('\n')
            self._printline(rstr, invert)  # Recurse

    def _splitpoint(self, string):
        if len(string) == 0:
            return 0
        sc = self._getstate().text_col
        wd = self.screenwidth
        l = sc
        splitpoint = 0
        i = 1
        for char in string[:-1]:
            if char == ' ':
                splitpoint = i
            _, _, char_width = self.font.get_ch(char)
            l += char_width
            if l > wd:
                return splitpoint
            i += 1

        l += self._truelen(string[-1])
        if l > wd:
            return splitpoint
        else:
            return i


    def stringlen(self, string, oh=False):
        if not len(string):
            return 0
        sc = self._getstate().text_col  # Start column
        wd = self.screenwidth
        l = 0
        for char in string[:-1]:
            _, _, char_width = self.font.get_ch(char)
            l += char_width
            if oh and l + sc > wd:
                return True  # All done. Save time.
        char = string[-1]
        _, _, char_width = self.font.get_ch(char)
        if oh and l + sc + char_width > wd:
            l += self._truelen(char)  # Last char might have blank cols on RHS
        else:
            l += char_width  # Public method. Return same value as old code.
        return l + sc > wd if oh else l

    # Return the printable width of a glyph less any blank columns on RHS
    def _truelen(self, char):
        glyph, ht, wd = self.font.get_ch(char)
        div, mod = divmod(wd, 8)
        gbytes = div + 1 if mod else div  # No. of bytes per row of glyph
        mc = 0  # Max non-blank column
        data = glyph[(wd - 1) // 8]  # Last byte of row 0
        for row in range(ht):  # Glyph row
            for col in range(wd -1, -1, -1):  # Glyph column
                gbyte, gbit = divmod(col, 8)
                if gbit == 0:  # Next glyph byte
                    data = glyph[row * gbytes + gbyte]
                if col <= mc:
                    break
                if data & (1 << (7 - gbit)):  # Pixel is lit (1)
                    mc = col  # Eventually gives rightmost lit pixel
                    break
            if mc + 1 == wd:
                break  # All done: no trailing space
        print('Truelen', char, wd, mc + 1)  # TEST 
        return mc + 1

    def _get_char(self, char, recurse):
        if not recurse:  # Handle tabs
            if char == '\n':
                self.cpos = 0
            elif char == '\t':
                nspaces = self.tab - (self.cpos % self.tab)
                if nspaces == 0:
                    nspaces = self.tab
                while nspaces:
                    nspaces -= 1
                    self._printchar(' ', recurse=True)
                self.glyph = None  # All done
                return

        self.glyph = None  # Assume all done
        if char == '\n':
            self._newline()
            return
        glyph, char_height, char_width = self.font.get_ch(char)
        s = self._getstate()
        np = None  # Allow restriction on printable columns
        if s.text_row + char_height > self.screenheight:
            if self.row_clip:
                return
            self._newline()
        oh = s.text_col + char_width - self.screenwidth  # Overhang (+ve)
        if oh > 0:
            if self.col_clip or self.wrap:
                np = char_width - oh  # No. of printable columns
                if np <= 0:
                    return
            else:
                self._newline()
        self.glyph = glyph
        self.char_height = char_height
        self.char_width = char_width
        self.clip_width = char_width if np is None else np
        
    # Method using blitting. Efficient rendering for monochrome displays.
    # Tested on SSD1306. Invert is for black-on-white rendering.
    def _printchar(self, char, invert=False, recurse=False):
        s = self._getstate()
        self._get_char(char, recurse)
        if self.glyph is None:
            return  # All done
        buf = bytearray(self.glyph)
        if invert:
            for i, v in enumerate(buf):
                buf[i] = 0xFF & ~ v
        fbc = framebuf.FrameBuffer(buf, self.clip_width, self.char_height, self.map)
        self.device.blit(fbc, s.text_col, s.text_row)
        s.text_col += self.char_width
        self.cpos += 1

    def tabsize(self, value=None):
        if value is not None:
            self.tab = value
        return self.tab

    def setcolor(self, *_):
        return self.fgcolor, self.bgcolor

# Writer for colour displays.
class CWriter(Writer):

    def __init__(self, buffer, width, height, font, fgcolor=None, bgcolor=None, verbose=True):
        super().__init__(buffer, width, height, font, verbose)
        self.palette = framebuf.FrameBuffer(bytearray(4),2,1, framebuf.RGB565)
        if bgcolor is not None:  # Assume monochrome.
            self.palette.pixel(0,0,bgcolor)
        if fgcolor is not None:
            self.palette.pixel(1,0,fgcolor)

    def _printchar(self, char, invert=False, recurse=False):
        s = self._getstate()
        self._get_char(char, recurse)
        if self.glyph is None:
            return  # All done
        fbc = framebuf.FrameBuffer(bytearray(self.glyph), self.clip_width, self.char_height, self.map)

        self.device.blit(fbc, s.text_col, s.text_row, -1, self.palette)
        s.text_col += self.char_width
        self.cpos += 1

    def setfg(self, color):
        self.palette.pixel(1,0,color)

    def setbg(self, color):
        self.palette.pixel(0,0,color)

def _color_card10_to_framebuf(color):
    color_framebuf = 1 # not transparent
    color_framebuf += (color.red & 0xf8) << 8
    color_framebuf += (color.green & 0xf8) << 3
    color_framebuf += (color.blue & 0xf8) >>2
    return color_framebuf

class TextBuffer():
    def __init__(self, font, width=160, height=None, buffer=None):
        if height is None:
            height = font.height()
        if buffer is None:
            self.buffer = framebuf.FrameBuffer(bytearray(width*height*2),width,height, framebuf.RGB565)
        else:
            self.buffer = buffer
        self.fgcolor = 0xffff
        self.bgcolor = 0x0000
        self.writer = CWriter(self.buffer, width, height, font, self.fgcolor, self.bgcolor, False)
        self.writer.set_clip(row_clip=True, col_clip=True, wrap=False)
        self.width = width
        self.height = height
        self.text = ""
        self.dirty = True

    def settext(self, text):
        if text != self.text:
            self.text = text
            self.dirty = True

    def setcolor(self, color):
        newfg = _color_card10_to_framebuf(color)
        self.fgcolor = newfg
        self.writer.setfg(newfg)

    def render(self, display, x, y):
        if self.dirty:
            self.buffer.fill(self.bgcolor)
            Writer.set_textpos(self.buffer, 0, 0)
            self.writer.printstring(self.text)
            self.dirty = False
        display.blit(x,y, self.width, self.height, self.buffer, card10_display.RGBA5551)

class MultilineTextBuffer():
    def __init__(self, width=160, height=80, scroll=True): # default is full screen
        self.width = width
        self.height = height
        self.buffer = framebuf.FrameBuffer(bytearray(width*height*2),width,height, framebuf.RGB565)
        self.rowclip = not scroll

    def clear(self):
        self.buffer.fill(0x0000)
        Writer.set_textpos(self.buffer, 0,0)

    def writer(self, font, color=None):
        color_framebuf = 0xffff
        if color is not None:
            color_framebuf = _color_card10_to_framebuf(color)
        writer = CWriter(self.buffer, self.width, self.height, font, color_framebuf, 0x0000, False)
        writer.set_clip(row_clip=self.rowclip)
        return writer

    def render(self, display, x=0, y=0):
        display.blit(x,y, self.width, self.height, self.buffer, card10_display.RGBA5551)