from machine import Pin, SoftSPI
import framebuf
import utime


# Native panel resolution (portrait, as the controller sees it)
EPD_NATIVE_WIDTH  = 122
EPD_NATIVE_HEIGHT = 250
_NATIVE_BUF_WIDTH = (EPD_NATIVE_WIDTH + 7) & ~7   # 128

# Logical resolution exposed to the user (landscape)
EPD_WIDTH  = 250
EPD_HEIGHT = 122
_FB_WIDTH  = (EPD_WIDTH + 7) & ~7                 # 256


_LUT_PARTIAL = bytes([
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00,
])


class EPD:
    # Public dimensions are the landscape ones
    WIDTH  = EPD_WIDTH
    HEIGHT = EPD_HEIGHT

    def __init__(self,
                 busy=6, rst=7, dc=8, cs=9,
                 sck=10, mosi=11, miso_placeholder=13):
        self.busy = Pin(busy, Pin.IN)
        self.rst  = Pin(rst,  Pin.OUT)
        self.dc   = Pin(dc,   Pin.OUT)
        self.cs   = Pin(cs,   Pin.OUT)

        self.cs.value(1)
        self.dc.value(0)
        self.rst.value(1)

        self.spi = SoftSPI(baudrate=2_000_000, polarity=0, phase=0,
                           sck=Pin(sck), mosi=Pin(mosi),
                           miso=Pin(miso_placeholder))

        # --- Native (portrait) buffers actually sent to the panel ---
        self._native_buf_w = _NATIVE_BUF_WIDTH                       # 128
        self._native_stride = self._native_buf_w // 8                # 16
        self.buffer = bytearray(self._native_buf_w * EPD_NATIVE_HEIGHT // 8)
        for i in range(len(self.buffer)):
            self.buffer[i] = 0xFF

        self._prev_buffer = bytearray(self._native_buf_w * EPD_NATIVE_HEIGHT // 8)
        for i in range(len(self._prev_buffer)):
            self._prev_buffer[i] = 0xFF

        # --- User-facing landscape framebuffer (drawn into directly) ---
        self._fb_w = _FB_WIDTH                                       # 256
        self._fb_h = EPD_HEIGHT                                      # 122
        self._fb_stride = self._fb_w // 8                            # 32
        self._fb_buf = bytearray(self._fb_w * self._fb_h // 8)
        self.fb = framebuf.FrameBuffer(self._fb_buf,
                                       self._fb_w, self._fb_h,
                                       framebuf.MONO_HLSB)
        self.fb.fill(0xFF)

        self._init_full()

    # ---------------- low-level I/O ----------------

    def _reset(self):
        self.rst.value(1); utime.sleep_ms(50)
        self.rst.value(0); utime.sleep_ms(5)
        self.rst.value(1); utime.sleep_ms(50)

    def _cmd(self, c):
        self.dc.value(0); self.cs.value(0)
        self.spi.write(bytes([c]))
        self.cs.value(1)

    def _data(self, d):
        self.dc.value(1); self.cs.value(0)
        if isinstance(d, int):
            self.spi.write(bytes([d]))
        else:
            self.spi.write(d)
        self.cs.value(1)

    def _wait_busy(self, timeout_ms=10000):
        t = 0
        while self.busy.value() == 1 and t < timeout_ms:
            utime.sleep_ms(10); t += 10
        if t >= timeout_ms:
            print("EPD BUSY timeout!")

    def _set_window(self, x_start_byte, x_end_byte, y_start, y_end):
        self._cmd(0x44)
        self._data(x_start_byte & 0xFF)
        self._data(x_end_byte & 0xFF)
        self._cmd(0x45)
        self._data(y_start & 0xFF); self._data((y_start >> 8) & 0xFF)
        self._data(y_end & 0xFF);   self._data((y_end >> 8) & 0xFF)

    def _set_cursor(self, x_byte, y):
        self._cmd(0x4E); self._data(x_byte & 0xFF)
        self._cmd(0x4F); self._data(y & 0xFF); self._data((y >> 8) & 0xFF)

    # ---------------- rotation ----------------

    def _rotate_to_native(self):
        """
        Rotate the landscape framebuffer into the native portrait buffer.

        Native pixel (x_n, y_n) with 0 <= x_n < 122, 0 <= y_n < 250
        maps to logical pixel (x_l, y_l) with:
            x_l = y_n
            y_l = (EPD_HEIGHT - 1) - x_n     # 90° rotation, text reads correctly
        """
        nat = self.buffer
        log = self._fb_buf
        nat_stride = self._native_stride
        log_stride = self._fb_stride
        h_minus_1  = EPD_HEIGHT - 1

        # Clear native buffer to white
        for i in range(len(nat)):
            nat[i] = 0xFF

        for y_n in range(EPD_NATIVE_HEIGHT):           # 0..249
            x_l = y_n
            if x_l >= EPD_WIDTH:                       # guard if buf padded beyond 250
                continue
            log_byte_col = x_l >> 3
            log_bit_shift = 7 - (x_l & 7)
            for x_n in range(EPD_NATIVE_WIDTH):        # 0..121
                y_l = h_minus_1 - x_n
                lb = log[y_l * log_stride + log_byte_col]
                bit = (lb >> log_bit_shift) & 1
                ni = y_n * nat_stride + (x_n >> 3)
                mask = 1 << (7 - (x_n & 7))
                if bit:
                    nat[ni] |= mask
                else:
                    nat[ni] &= ~mask

    # ---------------- panel init sequences ----------------

    def _init_full(self):
        self._reset()
        self._wait_busy()

        self._cmd(0x12)
        self._wait_busy()

        self._cmd(0x01)
        self._data(0xF9); self._data(0x00); self._data(0x00)

        self._cmd(0x11); self._data(0x03)

        self._set_window(0, (self._native_buf_w - 1) >> 3, 0, EPD_NATIVE_HEIGHT - 1)

        self._cmd(0x3C); self._data(0x05)
        self._cmd(0x21); self._data(0x00); self._data(0x80)
        self._cmd(0x18); self._data(0x80)

        self._set_cursor(0, 0)
        self._wait_busy()

    def _init_partial(self):
        self._cmd(0x32)
        self._data(_LUT_PARTIAL)

        self._cmd(0x3C); self._data(0x80)

        self._set_window(0, (self._native_buf_w - 1) >> 3, 0, EPD_NATIVE_HEIGHT - 1)
        self._set_cursor(0, 0)

    # ---------------- public display ops ----------------

    def display_full(self):
        self._rotate_to_native()
        self._init_full()

        self._set_cursor(0, 0)
        self._cmd(0x24)
        self._data(self.buffer)

        self._set_cursor(0, 0)
        self._cmd(0x26)
        self._data(self.buffer)

        self._cmd(0x22); self._data(0xF7)
        self._cmd(0x20)
        self._wait_busy()

        for i in range(len(self.buffer)):
            self._prev_buffer[i] = self.buffer[i]

    def display_partial(self):
        self._rotate_to_native()
        self._init_partial()

        self._set_cursor(0, 0)
        self._cmd(0x26)
        self._data(self._prev_buffer)

        self._set_cursor(0, 0)
        self._cmd(0x24)
        self._data(self.buffer)

        self._cmd(0x22); self._data(0xFF)
        self._cmd(0x20)
        self._wait_busy()

        for i in range(len(self.buffer)):
            self._prev_buffer[i] = self.buffer[i]

    def clear(self, color=0xFF):
        self.fb.fill(color)
        self.display_full()

    def sleep(self):
        self._cmd(0x10); self._data(0x01)
        utime.sleep_ms(100)

import os
import json
import time
from epd2in13 import EPD
from pico_ui_input import InputManager


CAL_FILE = 'calendar.json'

SAMPLE_EVENTS = {
    "2026-04-28": [
        {"time": "09:00", "title": "Standup"},
        {"time": "14:30", "title": "Dentist"},
        {"time": "19:00", "title": "Dinner with M"}
    ],
    "2026-04-30": [
        {"time": "10:00", "title": "Project review"}
    ],
    "2026-05-03": [
        {"time": "All day", "title": "Trip to Bursa"}
    ]
}

_CW = 8
_LH = 10
_EMG = 3
_PARTIALS_BEFORE_FULL = 25

# Filled in from epd.WIDTH / epd.HEIGHT in main()
# Portrait: 122 wide x 250 tall
_EW = 122
_EH = 250

_MONTHS = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
           'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')
_DOW = ('M', 'T', 'W', 'T', 'F', 'S', 'S')
_DOW_FULL = ('Monday', 'Tuesday', 'Wednesday', 'Thursday',
             'Friday', 'Saturday', 'Sunday')

# Scroll modes
_MODE_MONTH = 0
_MODE_DAY = 1


class _Refresher:
    def __init__(self, epd):
        self.epd = epd
        self.partials = 0

    def push(self, force_full=False):
        if force_full or self.partials >= _PARTIALS_BEFORE_FULL:
            self.epd.display_full()
            self.partials = 0
        else:
            if self.partials == 0:
                self.epd.display_full()
            else:
                self.epd.display_partial()
            self.partials += 1

    def push_full(self):
        self.epd.display_full()
        self.partials = 0


def _load_events():
    try:
        with open(CAL_FILE) as f:
            return json.load(f)
    except OSError:
        try:
            with open(CAL_FILE, 'w') as f:
                json.dump(SAMPLE_EVENTS, f)
        except Exception as e:
            print('write sample:', e)
        return dict(SAMPLE_EVENTS)
    except Exception as e:
        print('load events:', e)
        return {}


def _is_leap(y):
    return (y % 4 == 0 and y % 100 != 0) or (y % 400 == 0)


def _days_in_month(y, m):
    if m == 2:
        return 29 if _is_leap(y) else 28
    if m in (4, 6, 9, 11):
        return 30
    return 31


def _zeller_dow_monday0(y, m, d):
    if m < 3:
        m += 12
        y -= 1
    K = y % 100
    J = y // 100
    h = (d + (13 * (m + 1)) // 5 + K + K // 4 + J // 4 + 5 * J) % 7
    return (h + 5) % 7


def _today():
    try:
        t = time.localtime()
        return (t[0], t[1], t[2])
    except:
        return (2026, 4, 28)


def _date_key(y, m, d):
    return '{:04d}-{:02d}-{:02d}'.format(y, m, d)


def _advance(y, m, d, mode, step):
    """Advance (y, m, d) by `step` units of `mode` (day or month)."""
    if mode == _MODE_DAY:
        s = 1 if step > 0 else -1
        for _ in range(abs(step)):
            d += s
            if d > _days_in_month(y, m):
                d = 1
                m += 1
                if m > 12:
                    m = 1
                    y += 1
            elif d < 1:
                m -= 1
                if m < 1:
                    m = 12
                    y -= 1
                d = _days_in_month(y, m)
        return (y, m, d)
    else:
        m += step
        while m > 12:
            m -= 12
            y += 1
        while m < 1:
            m += 12
            y -= 1
        dim = _days_in_month(y, m)
        if d > dim:
            d = dim
        return (y, m, d)


def _draw_calendar(epd, refresher, y, m, sel_d, mode, events, full=False):
    """
    Portrait view (122 x 250), top-to-bottom:
      1. Header  : "MMM D YYYY" + day-of-week subtitle
      2. Grid    : day-of-week row + month grid with selected day inverted
      3. Events  : list for the selected day
      4. Footer  : scroll mode indicator
    """
    fb = epd.fb
    fb.fill(1)

    max_chars_w = (_EW - _EMG * 2) // _CW

    # -------- 1. Header --------
    hdr_y = _EMG
    title = '{} {} {}'.format(_MONTHS[m - 1], sel_d, y)
    if len(title) > max_chars_w:
        title = '{} {}'.format(_MONTHS[m - 1], sel_d)
    tx = (_EW - len(title) * _CW) // 2
    if tx < 0:
        tx = 0
    fb.text(title, tx, hdr_y, 0)

    sub_y = hdr_y + _LH + 1
    dow_idx = _zeller_dow_monday0(y, m, sel_d)
    sub = _DOW_FULL[dow_idx]
    if len(sub) > max_chars_w:
        sub = sub[:max_chars_w]
    sx = (_EW - len(sub) * _CW) // 2
    if sx < 0:
        sx = 0
    fb.text(sub, sx, sub_y, 0)

    sep1_y = sub_y + _LH + 2
    fb.hline(0, sep1_y, _EW, 0)

    # -------- 2. Day-of-week row + month grid --------
    grid_x0 = _EMG
    grid_w_avail = _EW - _EMG * 2
    cell_w = grid_w_avail // 7              # 116 // 7 = 16 px
    grid_w = cell_w * 7                     # 112 px
    # Center the grid horizontally given integer cell_w
    grid_x0 = (_EW - grid_w) // 2

    dow_y = sep1_y + 3
    for i in range(7):
        x = grid_x0 + i * cell_w + (cell_w - _CW) // 2
        fb.text(_DOW[i], x, dow_y, 0)
    dow_line_y = dow_y + _LH
    fb.hline(grid_x0, dow_line_y, grid_w, 0)

    n_days = _days_in_month(y, m)
    first_dow = _zeller_dow_monday0(y, m, 1)
    n_rows = (first_dow + n_days + 6) // 7

    # Reserve space at the bottom for events + footer
    foot_h = _LH + 2
    events_min_h = _LH * 3 + 6              # title + ~2 lines minimum
    grid_top = dow_line_y + 2
    grid_bottom_max = _EH - _EMG - foot_h - events_min_h - 2
    avail_h = grid_bottom_max - grid_top
    cell_h = avail_h // n_rows
    if cell_h < _LH + 2:
        cell_h = _LH + 2
    if cell_h > 16:
        cell_h = 16
    grid_h = n_rows * cell_h

    for r in range(n_rows + 1):
        ly = grid_top - 1 + r * cell_h
        fb.hline(grid_x0, ly, grid_w + 1, 0)
    for c in range(8):
        lx = grid_x0 + c * cell_w
        fb.vline(lx, grid_top - 1, grid_h + 1, 0)

    today_y, today_m, today_d = _today()

    for d in range(1, n_days + 1):
        idx = first_dow + (d - 1)
        row = idx // 7
        col = idx % 7
        cx = grid_x0 + col * cell_w
        cy = grid_top + row * cell_h

        is_sel = (d == sel_d)
        is_today = (y == today_y and m == today_m and d == today_d)

        if is_sel:
            fb.fill_rect(cx + 1, cy, cell_w - 1, cell_h - 1, 0)
            text_color = 1
        else:
            text_color = 0

        # cell_w is only ~16 px -> max 2 chars; print without leading space
        ds = str(d)
        tx2 = cx + (cell_w - len(ds) * _CW) // 2
        fb.text(ds, tx2, cy + 1, text_color)

        if is_today and not is_sel:
            fb.rect(cx + 1, cy, cell_w - 1, cell_h - 1, 0)

        if _date_key(y, m, d) in events:
            mx = cx + cell_w - 3
            my = cy + cell_h - 3
            fb.fill_rect(mx, my, 2, 2, 1 if is_sel else 0)

    sep2_y = grid_top + grid_h + 2
    fb.hline(0, sep2_y, _EW, 0)

    # -------- 3. Events --------
    body_top = sep2_y + 3
    foot_y = _EH - _EMG - _LH
    body_bottom = foot_y - 3

    key = _date_key(y, m, sel_d)
    day_events = events.get(key, [])

    if not day_events:
        fb.text('No events', _EMG, body_top, 0)
    else:
        y_cursor = body_top
        for i, ev in enumerate(day_events):
            if y_cursor + _LH > body_bottom:
                more = '+{} more'.format(len(day_events) - i)
                if len(more) > max_chars_w:
                    more = more[:max_chars_w]
                fb.text(more, _EMG, y_cursor, 0)
                break
            t = ev.get('time', '')
            title_s = ev.get('title', '')
            line = '{} {}'.format(t, title_s) if t else title_s
            if len(line) > max_chars_w:
                line = line[:max_chars_w]
            fb.text(line, _EMG, y_cursor, 0)
            y_cursor += _LH

    # -------- 4. Footer (mode indicator) --------
    fb.hline(0, foot_y - 2, _EW, 0)
    mode_str = 'Scroll: month' if mode == _MODE_MONTH else 'Scroll: day'
    if len(mode_str) > max_chars_w:
        mode_str = 'Mode: M' if mode == _MODE_MONTH else 'Mode: D'
    fb.text(mode_str, _EMG, foot_y, 0)

    refresher.push(force_full=full)


def _calendar_loop(epd, ui, refresher, events):
    today_y, today_m, today_d = _today()
    y, m, d = today_y, today_m, today_d
    mode = _MODE_MONTH

    _draw_calendar(epd, refresher, y, m, d, mode, events, full=True)

    while True:
        a = ui.wait()

        if a == 'dial+':
            y, m, d = _advance(y, m, d, mode, +1)
            _draw_calendar(epd, refresher, y, m, d, mode, events)

        elif a == 'dial-':
            y, m, d = _advance(y, m, d, mode, -1)
            _draw_calendar(epd, refresher, y, m, d, mode, events)

        elif a == 'dial_double':
            mode = _MODE_DAY if mode == _MODE_MONTH else _MODE_MONTH
            _draw_calendar(epd, refresher, y, m, d, mode, events)

        elif a == 'dial':
            y, m, d = today_y, today_m, today_d = _today()
            _draw_calendar(epd, refresher, y, m, d, mode, events)

        elif a == 'dial_long':
            return


def main():
    global _EW, _EH

    epd = EPD()
    _EW, _EH = epd.WIDTH, epd.HEIGHT

    ui = InputManager()
    ui.add_encoder('dial', clk=2, dt=3, sw=4,
                   long_press=True, double_click=True)

    refresher = _Refresher(epd)
    events = _load_events()

    _calendar_loop(epd, ui, refresher, events)

    epd.fb.fill(1)
    epd.display_full()
    epd.sleep()


if __name__ == '__main__':
    main()
else:
    main()

import os
import json
from machine import Pin, I2C
from epd2in13 import EPD
from pico_ui_input import InputManager


_CW = 8
_LH = 10
_EMG = 3
_PARTIALS_BEFORE_FULL = 15

# Portrait: 122 wide x 250 tall
_EW = 122
_EH = 250

OW, OH = 128, 64

BOOKMARKS_FILE = 'bookmarks.json'

try:
    from ssd1306 import SSD1306_I2C
    _i2c = I2C(0, sda=Pin(16), scl=Pin(17), freq=400_000)
    oled = SSD1306_I2C(OW, OH, _i2c)
    OLED_OK = True
except Exception as e:
    print('OLED unavailable:', e)
    oled = None
    OLED_OK = False


class _Refresher:
    def __init__(self, epd):
        self.epd = epd
        self.partials = 0

    def push(self, force_full=False):
        if force_full or self.partials >= _PARTIALS_BEFORE_FULL:
            self.epd.display_full()
            self.partials = 1
        else:
            if self.partials == 0:
                self.epd.display_full()
                self.partials = 1
            else:
                self.epd.display_partial()
                self.partials += 1

    def push_partial(self):
        if self.partials == 0:
            self.epd.display_full()
            self.partials = 1
        else:
            self.epd.display_partial()
            self.partials += 1

    def push_full(self):
        self.epd.display_full()
        self.partials = 1


def _load_bookmarks():
    try:
        with open(BOOKMARKS_FILE) as f:
            return json.load(f)
    except:
        return {}


def _save_bookmarks(bm):
    try:
        with open(BOOKMARKS_FILE, 'w') as f:
            json.dump(bm, f)
    except Exception as e:
        print('bookmark save:', e)


def _list_txt_files():
    out = []
    try:
        for name in os.listdir('/'):
            if name.lower().endswith('.txt'):
                out.append(name)
    except Exception as e:
        print('list_txt_files:', e)
    out.sort()
    return out


# ----------------- file list -----------------

def _draw_file_list(epd, refresher, files, sel, bookmarks,
                    full=False, force_partial=False):
    fb = epd.fb
    fb.fill(1)

    # Header
    fb.text('Library', _EMG, _EMG, 0)
    n = len(files)
    if n:
        cnt = '{}/{}'.format(sel + 1, n)
        cw = len(cnt) * _CW
        fb.text(cnt, _EW - _EMG - cw, _EMG, 0)
    sep_y = _EMG + _LH + 2
    fb.hline(0, sep_y, _EW, 0)

    if not files:
        fb.text('No .txt files', _EMG, sep_y + 8, 0)
        if force_partial:
            refresher.push_partial()
        else:
            refresher.push(force_full=full)
        return

    list_top = sep_y + 4
    list_bottom = _EH - _EMG
    # Each row uses _LH px; leave a 2-char left gutter for the cursor + bookmark mark
    left_gutter = _CW + 2          # 10 px: cursor (>) or space, then bookmark dot
    text_x = _EMG + left_gutter
    chars_per_line = max(1, (_EW - text_x - _EMG) // _CW)
    rows_visible = max(1, (list_bottom - list_top) // _LH)

    # Center the selection in the visible window where possible
    if sel < rows_visible // 2:
        first = 0
    elif sel > n - rows_visible // 2 - 1:
        first = max(0, n - rows_visible)
    else:
        first = sel - rows_visible // 2

    last = min(n, first + rows_visible)
    for i in range(first, last):
        y = list_top + (i - first) * _LH
        is_sel = (i == sel)
        name = files[i]
        if len(name) > chars_per_line:
            name = name[:chars_per_line - 1] + '~'

        if is_sel:
            fb.text('>', _EMG, y, 0)
        # bookmark indicator: solid dot before name if file has any bookmarks
        if bookmarks.get(files[i]):
            fb.fill_rect(_EMG + _CW, y + 3, 2, 2, 0)

        fb.text(name, text_x, y, 0)

    if force_partial:
        refresher.push_partial()
    else:
        refresher.push(force_full=full)


def _file_list_loop(epd, ui, refresher, bookmarks):
    files = _list_txt_files()
    sel = 0
    _draw_file_list(epd, refresher, files, sel, bookmarks, full=True)
    while True:
        a = ui.wait()
        if a == 'dial+':
            if files:
                sel = (sel + 1) % len(files)
                _draw_file_list(epd, refresher, files, sel, bookmarks,
                                force_partial=True)
        elif a == 'dial-':
            if files:
                sel = (sel - 1) % len(files)
                _draw_file_list(epd, refresher, files, sel, bookmarks,
                                force_partial=True)
        elif a == 'dial':
            if files:
                return files[sel]
        elif a == 'dial_long':
            return None


# ----------------- text wrapping -----------------

def _wrap_paragraph(text, cols):
    if not text:
        return ['']
    lines = []
    cur = ''
    for word in text.split(' '):
        if not word:
            continue
        while len(word) > cols:
            if cur:
                lines.append(cur); cur = ''
            lines.append(word[:cols])
            word = word[cols:]
        if not cur:
            cur = word
        elif len(cur) + 1 + len(word) <= cols:
            cur = cur + ' ' + word
        else:
            lines.append(cur); cur = word
    if cur:
        lines.append(cur)
    return lines


def _wrap_text(text, cols):
    out = []
    text = text.replace('\r\n', '\n').replace('\r', '\n')
    for para in text.split('\n'):
        if para == '':
            out.append('')
        else:
            out.extend(_wrap_paragraph(para, cols))
    return out


def _paginate(lines, rows_per_page):
    if rows_per_page < 1:
        rows_per_page = 1
    pages = []
    for i in range(0, len(lines), rows_per_page):
        pages.append(lines[i:i + rows_per_page])
    if not pages:
        pages = [['']]
    return pages


# ----------------- reader -----------------

# Layout constants for the reader chrome (top + bottom).
# Recomputed once and reused for both sizing and drawing so the math stays
# consistent.
_HDR_H        = _EMG + _LH + 2          # title row + 2 px under separator
_BAR_H        = 6                       # progress bar height (a touch slimmer)
_FOOT_H       = _BAR_H + 2 + _LH + 2    # bar + gap + page text + gap


def _draw_reader_page(epd, refresher, title, page_lines,
                      page_idx, n_pages, at_end=False, bookmarked=False,
                      full=False):
    fb = epd.fb
    fb.fill(1)

    chars_per_line = max(1, (_EW - _EMG * 2) // _CW)

    # ---- header ----
    title_avail = chars_per_line - (2 if bookmarked else 0)  # reserve space for icon
    title_disp = title
    if len(title_disp) > title_avail:
        title_disp = title_disp[:title_avail - 1] + '~'
    fb.text(title_disp, _EMG, _EMG, 0)

    if bookmarked:
        bx = _EW - _EMG - 6
        by = _EMG - 1
        # tiny bookmark glyph (filled rect with notched bottom)
        fb.fill_rect(bx, by, 6, 9, 0)
        fb.fill_rect(bx + 1, by + 8, 1, 2, 1)
        fb.fill_rect(bx + 4, by + 8, 1, 2, 1)

    sep_y = _EMG + _LH + 1
    fb.hline(0, sep_y, _EW, 0)

    # ---- body ----
    body_top = sep_y + 3
    body_bottom = _EH - _FOOT_H
    rows_per_page = max(1, (body_bottom - body_top) // _LH)

    for i, line in enumerate(page_lines):
        if i >= rows_per_page:
            break
        if line:
            fb.text(line, _EMG, body_top + i * _LH, 0)

    # ---- footer: page text + progress bar ----
    foot = 'END {}/{}'.format(page_idx + 1, n_pages) if at_end \
           else '{}/{}'.format(page_idx + 1, n_pages)
    if len(foot) * _CW > _EW - _EMG * 2:
        foot = '{}/{}'.format(page_idx + 1, n_pages)
    fw = len(foot) * _CW
    foot_y = _EH - _BAR_H - 2 - _LH
    fb.text(foot, _EW - _EMG - fw, foot_y, 0)

    # Progress bar at bottom
    bar_x0 = _EMG
    bar_x1 = _EW - _EMG
    bar_y  = _EH - _BAR_H - 1
    bar_w  = bar_x1 - bar_x0
    fb.rect(bar_x0, bar_y, bar_w, _BAR_H, 0)
    if n_pages > 1:
        fill_w = (bar_w - 4) * page_idx // (n_pages - 1)
    else:
        fill_w = bar_w - 4
    if fill_w > 0:
        fb.fill_rect(bar_x0 + 2, bar_y + 2, fill_w, _BAR_H - 4, 0)

    refresher.push(force_full=full)


def _reader_rows_per_page():
    body_top = _EMG + _LH + 1 + 3
    body_bottom = _EH - _FOOT_H
    return max(1, (body_bottom - body_top) // _LH)


# ----------------- OLED helpers (unchanged) -----------------

def _oled_clear():
    if OLED_OK:
        oled.fill(0); oled.show()


def _oled_menu(ui, title, items):
    if not OLED_OK:
        return None
    sel = 0
    while True:
        oled.fill(0)
        oled.fill_rect(0, 0, OW, 11, 1)
        title_short = title
        if len(title_short) > OW // 8 - 1:
            title_short = title_short[:OW // 8 - 1]
        oled.text(title_short, 2, 2, 0)

        body_top = 14
        row_h = 11
        rows_visible = (OH - body_top - 2) // row_h
        if sel < rows_visible // 2:
            first = 0
        elif sel > len(items) - rows_visible // 2 - 1:
            first = max(0, len(items) - rows_visible)
        else:
            first = sel - rows_visible // 2

        max_chars = OW // 8
        for i in range(first, min(len(items), first + rows_visible)):
            y = body_top + (i - first) * row_h
            label = items[i]
            if len(label) > max_chars:
                label = label[:max_chars]
            if i == sel:
                oled.fill_rect(0, y - 1, OW, row_h - 1, 1)
                oled.text(label, 2, y, 0)
            else:
                oled.text(label, 2, y, 1)
        oled.show()

        a = ui.wait()
        if a == 'dial+':
            sel = (sel + 1) % len(items)
        elif a == 'dial-':
            sel = (sel - 1) % len(items)
        elif a == 'dial':
            return sel
        elif a == 'dial_long':
            return None


def _oled_message(msg, sub=''):
    if not OLED_OK:
        return
    oled.fill(0)
    chars = OW // 8
    m = msg if len(msg) <= chars else msg[:chars]
    s = sub if len(sub) <= chars else sub[:chars]
    oled.text(m, (OW - len(m) * 8) // 2, OH // 2 - 8, 1)
    if s:
        oled.text(s, (OW - len(s) * 8) // 2, OH // 2 + 4, 1)
    oled.show()


def _show_bookmark_list(ui, page, marks):
    if not marks:
        _oled_message('No bookmarks')
        ui.wait()
        return None
    items = []
    sorted_marks = sorted(marks)
    for p in sorted_marks:
        marker = '*' if p == page else ' '
        items.append('{} p{}'.format(marker, p + 1))
    sel = _oled_menu(ui, 'Bookmarks', items)
    if sel is None:
        return None
    return sorted_marks[sel]


def _nearest_bookmark(marks, page, direction):
    if not marks:
        return None
    if direction > 0:
        candidates = [p for p in marks if p > page]
        if candidates:
            return min(candidates)
        return None
    else:
        candidates = [p for p in marks if p < page]
        if candidates:
            return max(candidates)
        return None


def _options_menu(ui, page, n_pages, marks):
    is_bookmarked = page in marks
    items = []
    actions = []

    if marks and any(p > page for p in marks):
        items.append('Skip >>')
        actions.append('skip_fwd')
    elif page < n_pages - 1:
        items.append('Jump end')
        actions.append('jump_end')

    if marks and any(p < page for p in marks):
        items.append('Skip <<')
        actions.append('skip_back')
    elif page > 0:
        items.append('Jump start')
        actions.append('jump_start')

    if is_bookmarked:
        items.append('Remove mark')
        actions.append('unmark')
    else:
        items.append('Set mark')
        actions.append('mark')

    items.append('Bookmarks...')
    actions.append('list')

    items.append('Exit book')
    actions.append('exit')

    items.append('Cancel')
    actions.append('cancel')

    sel = _oled_menu(ui, 'Options', items)
    if sel is None:
        return 'cancel'
    return actions[sel]


# ----------------- main reader loop -----------------

def _read_file_loop(epd, ui, refresher, filename, all_bookmarks):
    try:
        with open('/' + filename, 'r') as f:
            text = f.read()
    except Exception as e:
        fb = epd.fb
        fb.fill(1)
        fb.text('Error reading:', _EMG, _EMG, 0)
        fb.text(filename[:14], _EMG, _EMG + _LH * 2, 0)
        fb.text(str(e)[:14], _EMG, _EMG + _LH * 4, 0)
        refresher.push_full()
        ui.wait()
        return

    chars_per_line = max(1, (_EW - _EMG * 2) // _CW)
    rows_per_page = _reader_rows_per_page()

    lines = _wrap_text(text, chars_per_line)
    pages = _paginate(lines, rows_per_page)
    n = len(pages)
    title = filename.rsplit('.', 1)[0] if '.' in filename else filename

    marks = list(all_bookmarks.get(filename, []))
    marks = [p for p in marks if 0 <= p < n]
    marks_set = set(marks)

    page = 0
    if marks:
        page = max(marks)

    def _redraw(full=False):
        _draw_reader_page(epd, refresher, title, pages[page],
                          page, n, at_end=(page == n - 1),
                          bookmarked=(page in marks_set), full=full)

    _redraw(full=True)

    while True:
        a = ui.wait()
        if a == 'dial+':
            if page < n - 1:
                page += 1
                _redraw()
        elif a == 'dial-':
            if page > 0:
                page -= 1
                _redraw()
        elif a == 'dial_long':
            _oled_clear()
            return
        elif a == 'dial':
            choice = _options_menu(ui, page, n, marks_set)
            _oled_clear()
            if choice == 'cancel':
                pass
            elif choice == 'skip_fwd':
                target = _nearest_bookmark(marks_set, page, +1)
                if target is not None:
                    page = target
                    _redraw(full=True)
            elif choice == 'skip_back':
                target = _nearest_bookmark(marks_set, page, -1)
                if target is not None:
                    page = target
                    _redraw(full=True)
            elif choice == 'jump_end':
                page = n - 1
                _redraw(full=True)
            elif choice == 'jump_start':
                page = 0
                _redraw(full=True)
            elif choice == 'mark':
                marks_set.add(page)
                all_bookmarks[filename] = sorted(marks_set)
                _save_bookmarks(all_bookmarks)
                _oled_message('Bookmarked', 'p{}'.format(page + 1))
                _redraw()
            elif choice == 'unmark':
                marks_set.discard(page)
                if marks_set:
                    all_bookmarks[filename] = sorted(marks_set)
                else:
                    all_bookmarks.pop(filename, None)
                _save_bookmarks(all_bookmarks)
                _oled_message('Removed', 'p{}'.format(page + 1))
                _redraw()
            elif choice == 'list':
                target = _show_bookmark_list(ui, page, marks_set)
                _oled_clear()
                if target is not None:
                    page = target
                    _redraw(full=True)
            elif choice == 'exit':
                return


def main():
    global _EW, _EH

    epd = EPD()
    _EW, _EH = epd.WIDTH, epd.HEIGHT

    ui = InputManager()
    ui.add_encoder('dial', clk=2, dt=3, sw=4, long_press=True)

    refresher = _Refresher(epd)
    bookmarks = _load_bookmarks()

    while True:
        chosen = _file_list_loop(epd, ui, refresher, bookmarks)
        if chosen is None:
            break
        _read_file_loop(epd, ui, refresher, chosen, bookmarks)
        # Bookmarks may have changed inside the reader; reload from memory.

    epd.fb.fill(1)
    epd.display_full()
    epd.sleep()
    _oled_clear()


if __name__ == '__main__':
    main()
else:
    main()

"""
Pico flashcards — Anki-style SRS on e-ink + OLED + rotary encoder.
Portrait (122x250) layout.

Storage: flashcards.json   (auto-created with a sample deck on first run)
SRS:     simplified SM-2 (Again/Hard/Good/Easy)
Controls:
  rotate     = scroll / select
  click      = confirm / show answer / grade
  long-press = back / exit
  double     = jump to deck list
"""

from machine import Pin, I2C
import time, json, gc

from epd2in13 import EPD
from ssd1306 import SSD1306_I2C
from pico_ui_input import InputManager


# ---------- constants ----------

DB_FILE = 'flashcards.json'
DAY_S = 86400
MIN_EASE = 1.30
START_EASE = 2.50

GRADES = ('Again', 'Hard', 'Good', 'Easy')

DEFAULT_DB = {
    'baseline': 0,
    'decks': [
        {
            'name': 'Sample',
            'cards': [
                {'q': 'Capital of France?', 'a': 'Paris',
                 'iv': 0, 'ef': START_EASE, 'due': 0, 'reps': 0},
                {'q': '2 + 2 = ?', 'a': '4',
                 'iv': 0, 'ef': START_EASE, 'due': 0, 'reps': 0},
                {'q': 'H2O is...', 'a': 'water',
                 'iv': 0, 'ef': START_EASE, 'due': 0, 'reps': 0},
            ],
        },
    ],
}


# ---------- DB load / save ----------

def load_db():
    try:
        with open(DB_FILE) as f:
            db = json.load(f)
        for deck in db.get('decks', []):
            for c in deck.get('cards', []):
                c.setdefault('iv', 0)
                c.setdefault('ef', START_EASE)
                c.setdefault('due', 0)
                c.setdefault('reps', 0)
        db.setdefault('baseline', 0)
        return db
    except (OSError, ValueError):
        save_db(DEFAULT_DB)
        return DEFAULT_DB


def save_db(db):
    try:
        with open(DB_FILE, 'w') as f:
            json.dump(db, f)
    except Exception as e:
        print('save_db:', e)


def now_s():
    return time.time()


# ---------- SRS core ----------

def schedule(card, grade_idx):
    ef = card['ef']
    iv = card['iv']
    reps = card['reps']

    if grade_idx == 0:                 # Again
        ef = max(MIN_EASE, ef - 0.20)
        iv = 1
        reps = 0
    elif grade_idx == 1:               # Hard
        ef = max(MIN_EASE, ef - 0.15)
        iv = max(1, int(round(iv * 1.2))) if iv > 0 else 1
        reps += 1
    elif grade_idx == 2:               # Good
        if reps == 0:
            iv = 1
        elif reps == 1:
            iv = 3
        else:
            iv = max(1, int(round(iv * ef)))
        reps += 1
    else:                              # Easy
        ef = ef + 0.15
        if reps == 0:
            iv = 4
        elif reps == 1:
            iv = 7
        else:
            iv = max(1, int(round(iv * ef * 1.3)))
        reps += 1

    card['ef'] = round(ef, 3)
    card['iv'] = iv
    card['reps'] = reps
    card['due'] = now_s() + iv * DAY_S


def due_count(deck, now=None):
    if now is None:
        now = now_s()
    n = 0
    for c in deck['cards']:
        if c['due'] <= now:
            n += 1
    return n


def collect_due_cards(deck, now=None):
    if now is None:
        now = now_s()
    return [i for i, c in enumerate(deck['cards']) if c['due'] <= now]


# ---------- hardware setup ----------

epd = EPD()
EW, EH = epd.WIDTH, epd.HEIGHT       # 122 x 250 in portrait
EMG = 3
CW, LH = 8, 10

i2c0 = I2C(0, sda=Pin(16), scl=Pin(17), freq=400_000)
try:
    oled = SSD1306_I2C(128, 64, i2c0)
    OLED_OK = True
except Exception as e:
    print('OLED init failed:', e)
    oled = None
    OLED_OK = False
OW, OH = 128, 64


class _Refresher:
    def __init__(self, ep):
        self.ep = ep
        self.partials = 0

    def push(self, force_full=False):
        if force_full or self.partials >= 5:
            self.ep.display_full()
            self.partials = 0
        else:
            if self.partials == 0:
                self.ep.display_full()
            else:
                self.ep.display_partial()
            self.partials += 1


refresher = _Refresher(epd)

ui = InputManager()
ui.add_encoder('dial', clk=2, dt=3, sw=4,
               long_press=True, double_click=True)


# ---------- text helpers ----------

def _fit(s, max_w):
    n = max(0, max_w // CW)
    return s if len(s) <= n else s[:n]


def _wrap_lines(s, max_chars):
    if max_chars <= 0:
        return []
    out = []
    for paragraph in s.split('\n'):
        if not paragraph:
            out.append('')
            continue
        words = paragraph.split(' ')
        cur = ''
        for w in words:
            if len(w) > max_chars:
                if cur:
                    out.append(cur); cur = ''
                while len(w) > max_chars:
                    out.append(w[:max_chars])
                    w = w[max_chars:]
                cur = w
                continue
            if not cur:
                cur = w
            elif len(cur) + 1 + len(w) <= max_chars:
                cur = cur + ' ' + w
            else:
                out.append(cur); cur = w
        if cur:
            out.append(cur)
    return out


# ---------- e-ink screens ----------

def render_deck_list(decks, sel):
    """
    Vertical list of decks. Two rows per deck: name on row 1,
    "due: N" on row 2 in muted style. Avoids name truncation on a 14-char screen.
    """
    fb = epd.fb
    fb.fill(1)

    # Header
    fb.text(_fit('Decks', EW - EMG * 2), EMG, EMG, 0)
    cnt = '{}/{}'.format(sel + 1, len(decks)) if decks else '0/0'
    cw = len(cnt) * CW
    fb.text(cnt, EW - EMG - cw, EMG, 0)
    sep_y = EMG + 8 + 2
    fb.hline(0, sep_y, EW, 0)

    # Footer
    foot_h = 8
    sep_yb = EH - EMG - foot_h - 2
    fb.hline(0, sep_yb, EW, 0)
    fb.text(_fit('hold to quit', EW - EMG * 2),
            EMG, EH - EMG - foot_h, 0)

    body_top = sep_y + 4
    body_bot = sep_yb - 2
    row_h = LH * 2 + 3                           # name + count + small gap
    max_rows = max(1, (body_bot - body_top) // row_h)

    start = 0
    if len(decks) > max_rows:
        start = max(0, min(sel - max_rows // 2, len(decks) - max_rows))
    end = min(len(decks), start + max_rows)

    name_max = max(1, (EW - EMG * 2 - CW) // CW)  # leave room for cursor

    for vis_i, idx in enumerate(range(start, end)):
        deck = decks[idx]
        n = due_count(deck)
        y = body_top + vis_i * row_h
        is_sel = (idx == sel)

        if is_sel:
            # Cursor + bold-ish (we only have one weight so just cursor)
            fb.text('>', EMG, y, 0)
        name = deck['name'][:name_max]
        fb.text(name, EMG + CW, y, 0)

        sub = 'due: {}'.format(n)
        fb.text(sub, EMG + CW, y + LH, 0)

    refresher.push(force_full=True)


def render_card(deck_name, card, idx, total, show_answer, grade_sel,
                full=False):
    """
    Portrait card screen.

    show_answer=False:
      header | wrapped question (centered vertically) | hint
    show_answer=True:
      header | question (top, ~2 lines) | divider | answer (wrapped) |
      vertical 4-row grade bar | hint
    """
    fb = epd.fb
    fb.fill(1)

    chars = max(1, (EW - EMG * 2) // CW)

    # ---- header ----
    progress = '{}/{}'.format(idx + 1, total)
    pw = len(progress) * CW
    name_w = EW - EMG * 2 - pw - CW
    name = _fit(deck_name, name_w)
    fb.text(name, EMG, EMG, 0)
    fb.text(progress, EW - EMG - pw, EMG, 0)
    sep_y = EMG + 8 + 2
    fb.hline(0, sep_y, EW, 0)

    # ---- footer ----
    foot_h = 8
    sep_yb = EH - EMG - foot_h - 2
    fb.hline(0, sep_yb, EW, 0)

    body_top = sep_y + 3
    body_bot = sep_yb - 2
    body_h = body_bot - body_top

    if not show_answer:
        lines = _wrap_lines(card['q'], chars)
        max_lines = body_h // LH
        if len(lines) > max_lines:
            lines = lines[:max_lines]
        total_h = len(lines) * LH
        ystart = body_top + max(0, (body_h - total_h) // 2)
        for i, ln in enumerate(lines):
            tx = (EW - len(ln) * CW) // 2
            if tx < EMG:
                tx = EMG
            fb.text(ln, tx, ystart + i * LH, 0)

        fb.text(_fit('click to flip', EW - EMG * 2),
                EMG, EH - EMG - foot_h, 0)

    else:
        # Vertical grade bar at the bottom of the body area: 4 rows,
        # each row 13 px tall (text + 3 px padding). Total = 52 px.
        gb_row_h = 13
        gb_h = gb_row_h * len(GRADES)
        gb_y0 = body_bot - gb_h

        # Question + divider + answer fit in the area above the grade bar.
        qa_top = body_top
        qa_bot = gb_y0 - 2
        qa_h = qa_bot - qa_top

        # Allow up to 2 lines for question, rest for answer.
        q_lines = _wrap_lines(card['q'], chars)
        if len(q_lines) > 2:
            q_lines = q_lines[:2]
        q_h = len(q_lines) * LH

        for i, ln in enumerate(q_lines):
            fb.text(ln, EMG, qa_top + i * LH, 0)

        div_y = qa_top + q_h + 1
        # dotted-ish divider: skip every other pixel
        for x in range(EMG + 2, EW - EMG - 2, 2):
            fb.pixel(x, div_y, 0)

        a_top = div_y + 3
        a_h = qa_bot - a_top
        a_max_lines = max(1, a_h // LH)
        a_lines = _wrap_lines(card['a'], chars)
        if len(a_lines) > a_max_lines:
            a_lines = a_lines[:a_max_lines - 1] + [a_lines[a_max_lines - 1][:chars - 1] + '~']
        for i, ln in enumerate(a_lines):
            fb.text(ln, EMG, a_top + i * LH, 0)

        # Vertical grade bar
        for gi, g in enumerate(GRADES):
            cy = gb_y0 + gi * gb_row_h
            label = g[:chars]
            tx = EMG + max(0, (EW - EMG * 2 - len(label) * CW) // 2)
            ty = cy + (gb_row_h - LH) // 2 + 1
            if gi == grade_sel:
                fb.fill_rect(EMG, cy, EW - EMG * 2, gb_row_h, 0)
                fb.text(label, tx, ty, 1)
            else:
                fb.rect(EMG, cy, EW - EMG * 2, gb_row_h, 0)
                fb.text(label, tx, ty, 0)

        fb.text(_fit('turn pick click ok', EW - EMG * 2),
                EMG, EH - EMG - foot_h, 0)

    refresher.push(force_full=full)


def render_session_done(deck_name, reviewed):
    fb = epd.fb
    fb.fill(1)
    title = _fit('Session done', EW - EMG * 2)
    fb.text(title, (EW - len(title) * CW) // 2, EH // 2 - 20, 0)
    sub = _fit('{} cards'.format(reviewed), EW - EMG * 2)
    fb.text(sub, (EW - len(sub) * CW) // 2, EH // 2 - 4, 0)
    nm = _fit(deck_name, EW - EMG * 2)
    fb.text(nm, (EW - len(nm) * CW) // 2, EH // 2 + 10, 0)
    hint = _fit('click=continue', EW - EMG * 2)
    fb.text(hint, (EW - len(hint) * CW) // 2, EH - EMG - 8, 0)
    refresher.push(force_full=True)


def render_empty_deck(deck_name):
    fb = epd.fb
    fb.fill(1)
    msg = _fit('Nothing due', EW - EMG * 2)
    fb.text(msg, (EW - len(msg) * CW) // 2, EH // 2 - 12, 0)
    nm = _fit(deck_name, EW - EMG * 2)
    fb.text(nm, (EW - len(nm) * CW) // 2, EH // 2, 0)
    hint = _fit('click=back', EW - EMG * 2)
    fb.text(hint, (EW - len(hint) * CW) // 2, EH - EMG - 8, 0)
    refresher.push(force_full=True)


# ---------- OLED screens (unchanged — different display) ----------

def oled_status(deck_name, remaining, last_grade=None):
    if not OLED_OK: return
    oled.fill(0)
    oled.fill_rect(0, 0, OW, 11, 1)
    name = deck_name[:max(1, OW // 8 - 1)]
    oled.text(name, 2, 2, 0)

    oled.text('Left: {}'.format(remaining), 0, 18, 1)
    lg = last_grade if last_grade is not None else '-'
    oled.text('Last: {}'.format(lg), 0, 32, 1)
    oled.text('hold=quit', 0, OH - 8, 1)
    oled.show()


def oled_decks_hint(n_decks):
    if not OLED_OK: return
    oled.fill(0)
    oled.fill_rect(0, 0, OW, 11, 1)
    oled.text('Flashcards', 2, 2, 0)
    oled.text('Decks: {}'.format(n_decks), 0, 18, 1)
    oled.text('rotate=pick', 0, 32, 1)
    oled.text('click=open', 0, 44, 1)
    oled.text('hold=quit', 0, OH - 8, 1)
    oled.show()


def oled_clear():
    if OLED_OK:
        oled.fill(0); oled.show()


# ---------- review session ----------

def review_deck(db, deck):
    queue = collect_due_cards(deck)
    if not queue:
        render_empty_deck(deck['name'])
        oled_status(deck['name'], 0, None)
        while True:
            a = ui.wait()
            if a in ('dial', 'dial_long', 'dial_double'):
                return 0

    reviewed = 0
    last_grade = None
    pos = 0

    while pos < len(queue):
        card_idx = queue[pos]
        card = deck['cards'][card_idx]

        # Phase 1: question only
        render_card(deck['name'], card, pos, len(queue),
                    show_answer=False, grade_sel=2, full=(pos == 0))
        oled_status(deck['name'], len(queue) - pos, last_grade)

        flipped = False
        while not flipped:
            a = ui.wait()
            if a == 'dial':
                flipped = True
            elif a == 'dial_long':
                save_db(db)
                return reviewed
            elif a == 'dial_double':
                save_db(db)
                return reviewed

        # Phase 2: answer + grading
        grade_sel = 2
        render_card(deck['name'], card, pos, len(queue),
                    show_answer=True, grade_sel=grade_sel)

        graded = False
        while not graded:
            a = ui.wait()
            if a == 'dial+':
                grade_sel = (grade_sel + 1) % len(GRADES)
                render_card(deck['name'], card, pos, len(queue),
                            show_answer=True, grade_sel=grade_sel)
            elif a == 'dial-':
                grade_sel = (grade_sel - 1) % len(GRADES)
                render_card(deck['name'], card, pos, len(queue),
                            show_answer=True, grade_sel=grade_sel)
            elif a == 'dial':
                schedule(card, grade_sel)
                last_grade = GRADES[grade_sel]
                reviewed += 1
                save_db(db)
                if grade_sel == 0:
                    queue.append(card_idx)
                graded = True
            elif a in ('dial_long', 'dial_double'):
                save_db(db)
                return reviewed

        pos += 1
        gc.collect()

    render_session_done(deck['name'], reviewed)
    oled_status(deck['name'], 0, last_grade)
    while True:
        a = ui.wait()
        if a in ('dial', 'dial_long', 'dial_double'):
            return reviewed


# ---------- deck list mode ----------

def deck_list_mode(db):
    sel = 0
    decks = db['decks']
    if not decks:
        decks = list(DEFAULT_DB['decks'])
        db['decks'] = decks
        save_db(db)

    render_deck_list(decks, sel)
    oled_decks_hint(len(decks))

    while True:
        a = ui.wait()
        if a == 'dial+':
            sel = (sel + 1) % len(decks)
            render_deck_list(decks, sel)
        elif a == 'dial-':
            sel = (sel - 1) % len(decks)
            render_deck_list(decks, sel)
        elif a == 'dial':
            review_deck(db, decks[sel])
            render_deck_list(decks, sel)
            oled_decks_hint(len(decks))
        elif a == 'dial_long':
            return


# ---------- main ----------

def main():
    db = load_db()
    if db.get('baseline', 0) == 0:
        db['baseline'] = now_s()
        save_db(db)
    try:
        deck_list_mode(db)
    finally:
        save_db(db)
        oled_clear()


if __name__ == '__main__':
    main()
else:
    main()