import numpy as np
from micropython import const
#TODO: I probably need more includes here for standalone operation (SPI bus stuff, etc...)
#TODO: Combine the spi send stuff into a differnt function?

_SHARPMEM_BIT_WRITECMD = const(0x80)  # in lsb
_SHARPMEM_BIT_VCOM = const(0x40)  # in lsb
_SHARPMEM_BIT_CLEAR = const(0x20)  # in lsb

def reverse_bit(num):
    """Turn an LSB byte to an MSB byte, and vice versa. Used for SPI as
    it is LSB for the SHARP, but 99% of SPI implementations are MSB only!"""
    result = 0
    for _ in range(8):
        result <<= 1
        result += num & 1
        num >>= 1
    return result

class SharpDisplay:
    """A driver for sharp memory displays, you can use any size but the
    full display must be buffered in memory!"""

    def __init__(self, spi, scs_pin, width, height, *, baudrate=2000000):
        self._scs_pin = scs_pin
        scs_pin.switch_to_output(value=True)
        self._baudrate = baudrate
        self._displaywidth = width
        self._displayheight = height
        # The SCS pin is active HIGH so we can't use bus_device. exciting!
        self._spi = spi

        #Numpy array for the frame data. TODO: Not sure if there is a reason to preallocate this...
        self.buffer = np.zeros((height, (width // 8)), dtype=np.uint8)
        
        #Precompute headers and tail arrays
        self._HeaderVals = np.zeros((self._displayheight, 2), dtype=np.uint8)
        for i in range (0,self._displayheight):
            self._HeaderVals[i,1] = reverse_bit(i+1)

        self._TailVals = np.array([0, 0], dtype=np.uint8)

        # Set the vcom bit to a defined state
        self._vcom = True

    def ShowFrame(self, img):
        """write out the frame buffer via SPI, we use MSB SPI only so some
        bit-swapping is rquired. The display also uses inverted CS for some
        reason so we con't use bus_device"""
    
        #Import image and convert
        self.buffer = np.packbits(np.asarray(img), axis=1)
        DisplayBuffer = np.append(np.hstack((self._HeaderVals, self.buffer)),self._TailVals).tolist()

        # CS pin is inverted so we have to do this all by hand
        while not self._spi.try_lock():
            pass
        self._spi.configure(baudrate=self._baudrate)
        self._scs_pin.value = True

        # toggle the VCOM bit
        CommandByte = _SHARPMEM_BIT_WRITECMD
        if self._vcom:
            CommandByte |= _SHARPMEM_BIT_VCOM
        self._vcom = not self._vcom
        DisplayBuffer[0] = CommandByte
        self._spi.write(DisplayBuffer)

        self._scs_pin.value = False
        self._spi.unlock()
        
    def UpdateDisplay(self):
        """This function should be called approx once per second whenever the display is not updated
        This function switches the polarity of the display. This is supposed to happen about once a second"""   
        CommandByte = bytearray(1)
        
        # CS pin is inverted so we have to do this all by hand
        while not self._spi.try_lock():
            pass
        self._spi.configure(baudrate=self._baudrate)
        self._scs_pin.value = True

        # toggle the VCOM bit
        CommandByte[0] = 0x00
        if self._vcom:
            CommandByte[0] |= _SHARPMEM_BIT_VCOM
        self._vcom = not self._vcom
        self._spi.write(CommandByte)

        self._scs_pin.value = False
        self._spi.unlock()
        
    def BlankDisplay(self):
        """Call to clear the memory and write all white to the display"""
        CommandByte = bytearray(1)        
        # CS pin is inverted so we have to do this all by hand
        while not self._spi.try_lock():
            pass
        self._spi.configure(baudrate=self._baudrate)
        self._scs_pin.value = True

        # toggle the VCOM bit
        CommandByte[0] = _SHARPMEM_BIT_CLEAR
        if self._vcom:
            CommandByte[0] |= _SHARPMEM_BIT_VCOM
        self._vcom = not self._vcom
        self._spi.write(CommandByte)

        self._scs_pin.value = False
        self._spi.unlock()
        

        #Convert a PIL image to the adafruit framebuffer format
        DisplayBuffer = np.packbits(np.asarray(img), axis=1).flatten().tolist()
        
        HeaderBytes = bytearray([0x00,0x00])
        addressToSend = self._displayheight+1
        for x in range(((self._displaywidth // 8) * self._displayheight), 0, -1*(self._displaywidth // 8)):
            HeaderBytes[1] = reverse_bit(addressToSend)
            DisplayBuffer[x:x] = HeaderBytes
            addressToSend = addressToSend - 1
        
        HeaderBytes[1] = reverse_bit(addressToSend)
        DisplayBuffer[0:0] = HeaderBytes

        #Convert a PIL image to the adafruit framebuffer format
        DisplayBuffer = np.packbits(np.asarray(img), axis=1).flatten().tolist()
        
        pc_index = len(self._HeaderVals_ada)-1  #start at the top of the list, count down.
        for x in range(((self._displaywidth // 8) * self._displayheight), 0, -1*(self._displaywidth // 8)):
            DisplayBuffer[x:x] = self._HeaderVals_ada[pc_index]
            pc_index = pc_index - 1
        
        DisplayBuffer[0:0] = self._HeaderVals_ada[pc_index]

        #Import image and convert
        self.buffer = np.packbits(np.asarray(img), axis=1)
        DisplayBuffer = np.append(np.hstack((self._HeaderVals, self.buffer)),self._TailVals).tolist()   #Note: append also flattens the matrix