import adafruit_ssd1306
import busio
import time

from kmk.modules import Module

class Oled(Module):
    def __init__(self, pin1=None, pin2=None, i2c=None, startup_image = None, anim1 = None, anim2 = None):
        print("Init OLED")
        if i2c is None:
            self.i2c = busio.I2C(scl=pin1, sda=pin2)
        else:
            self.i2c = i2c
        self.startup_image = startup_image
        self.anims = [anim1, anim2]
        self.anim_state = 0
        self.last_state = None
        self.oled = adafruit_ssd1306.SSD1306_I2C(128, 32, self.i2c)
        self.oled.text("Init", 0, 0, 1)
        self.oled.show()
        self.inactive_timer = time.time()
        self.timeout = 3
        self.inactive_timeout = 30
        self.last_anim = 0
        

    def _oled_blank(self):
        self.oled.fill(0)
        self.oled.show()

    def _draw_image(self, image, size=(32, 128), offset=0, clear=False):
        print("calling draw_image")
        if clear:
            self.oled.fill(0)
        for i in range(size[0]):
            for j in range(size[1]):
                if image[i][j] is False:
                    continue
                # self.oled.buffer[i + j] = image[i][j]
                self.oled.pixel(j+offset, i, 0 if image[i][j] is False else True)
        # self.oled_changed = True
        self.oled.show()

    def during_bootup(self, keyboard):
        if self.startup_image is not None:
            self._draw_image(self.startup_image, clear=True)
        
        print("booting") 
        keyboard.oled = self
        return

    def before_matrix_scan(self, keyboard):
        return

    def before_hid_send(self, keyboard):
        return

    def after_hid_send(self, keyboard):
        return

    def on_powersave_enable(self, keyboard):
        return

    def on_powersave_disable(self, keyboard):
        return

    def after_matrix_scan(self, keyboard):
        curr_time = time.time()
        # print(time.time(), self.timeout + self.last_anim )
        if curr_time > self.timeout + self.last_anim and self.last_anim != 0:
            self._draw_image(self.startup_image, clear = True)
            self.last_anim = 0
        if curr_time > self.inactive_timer + self.inactive_timeout:
            self._oled_blank()
        return

    def process_key(self, keyboard, key, is_pressed):
        curr_time = time.time()
        if is_pressed == 1:
            # Move the drawing out of process_key
            # self._draw_image(self.anims[self.anim_state], (32,32), 64-16, True)
            self.anim_state = 1 if self.anim_state == 0 else 0
            self.last_anim = curr_time
        self.inactive_timer = curr_time
        return super().process_key(keyboard, key, is_pressed)