{
    Prog->Notepad - GUI text editor

    Features:
      - Open / Save / Save As via inline file picker
      - Text selection (Shift+Arrow keys)
      - Delete selected range on Backspace / Del
      - Tab to indent selected lines (4 spaces), Shift+Tab to dedent
      - Ctrl+A to select all, Ctrl+S to save
      - Word-wrap toggle (via Wrap button)
      - Status bar showing Line, Col, filename, and dirty flag

    Key design notes:
      - lv_event_t.stop_processing (bit 1 at struct byte offset 24) is set
        directly to prevent LVGL's default textarea key handler from also
        acting on keys we have fully handled ourselves.
      - Shift state is read from driver.hid.keyboard.is_shift / driver.hid.keyboard.is_ctrl.
      - selection anchor (sel_anchor) is stored as a sint32 byte offset;
        -1 means no selection is active.

    @author(Aaron Hance <ah@aaronhance.me>)
}
unit app.notepad;

interface

procedure init();

implementation

uses
    driver.video.desktop,
    app.filepicker,
    driver.hid.keyboard,
    memory.heap,
    driver.video.lvgl,
    proc.mgr,
    proc.types,
    driver.storage.types,
    driver.storage.filedispatch,
    core.strings,
    core.strings.helpers,
    io.syslog,
    io.stdio,
    debug.tracer,
    core.util, arch.x86.util,
    driver.storage.vfs,
    driver.video,
    driver.video.windows;

const
    WIN_W               = 700;
    WIN_H               = 500;
    TOOLBAR_H           = 40;
    STATUSBAR_H         = 24;
    MAX_NOTEPAD_INST    = 8;

    { LV_DRAW_LABEL_NO_TXT_SEL — sentinel returned when no selection is set }
    LV_NO_SEL      = $FFFF;
    { LV_TEXTAREA_CURSOR_LAST — pass to set_cursor_pos to go to end-of-text }
    LV_CURSOR_LAST = $7FFF;

    FILE_BUF_SIZE  = 65536;   { 64 KB read / write buffer }

    {
      Byte offset and bitmask for lv_event_t.stop_processing.
      struct lv_event_t (32-bit ABI):
        offset  0: current_target  (ptr)
        offset  4: original_target (ptr)
        offset  8: code            (uint32  — lv_event_code_t)
        offset 12: user_data       (ptr)
        offset 16: param           (ptr)
        offset 20: prev            (ptr)
        offset 24: flags byte      [bit0=deleted, bit1=stop_processing, bit2=stop_bubbling]
    }
    LV_EVT_STOP_OFF = 24;
    LV_EVT_STOP_BIT = 2;    { bit 1 = stop_processing }

type
    PNotepadState = ^TNotepadState;
    TNotepadState = record
        win_id             : uint32;
        pid          : uint32;
        ta           : Plv_obj;
        status_label : Plv_obj;
        dirty_label  : Plv_obj;
        currentPath  : pchar;
        isDirty      : boolean;
        sel_anchor   : sint32;
    end;

{ ============================================================
  Module-level state (multi-instance)
  ============================================================ }
var
    g_instances        : array[0..MAX_NOTEPAD_INST-1] of PNotepadState;
    g_inst_count       : uint32;
    { File-dispatch deferred open }
    g_dispatch_path    : pchar;
    g_dispatch_pending : uint32;
    g_dispatch_timer   : Plv_timer;

{ ============================================================
  Forward declarations
  ============================================================ }
procedure notepad_entry(ctx: PProcessContext); forward;
function  launchInstance: PNotepadState; forward;
procedure launch; forward;
procedure onClose(wid: uint32); forward;
procedure updateStatusBar(state: PNotepadState); forward;
procedure saveFile(state: PNotepadState); forward;
procedure loadFile(state: PNotepadState; path: pchar); forward;
procedure performNew(state: PNotepadState); forward;
procedure freeState(state: PNotepadState); forward;
procedure doCloseWindow(state: PNotepadState); forward;
procedure showDiscardMsgbox(discard_cb: lv_event_cb_t; state: PNotepadState); forward;
procedure showErrorMsgbox(title: pchar; msg: pchar); forward;
procedure mbox_cancel_cb(e: Plv_event); cdecl; forward;
procedure np_open_done_cb(path: pchar; userdata: pointer); cdecl; forward;
procedure np_saveas_done_cb(path: pchar; userdata: pointer); cdecl; forward;
function  findStateByWid(wid: uint32): PNotepadState; forward;
procedure addInstance(state: PNotepadState); forward;
procedure removeInstance(state: PNotepadState); forward;

{ ============================================================
  stopEvent — set LVGL's stop_processing flag in the event
  struct so the widget's default key handler does not run.
  User callbacks fire BEFORE the widget class handler, so this
  correctly suppresses LVGL's default action.
  ============================================================ }
procedure stopEvent(e: Plv_event);
begin
    puint8(uint32(e) + LV_EVT_STOP_OFF)^ :=
        puint8(uint32(e) + LV_EVT_STOP_OFF)^ or LV_EVT_STOP_BIT;
end;

{ ============================================================
  buildSplicedString
  Returns a new kalloc'd pchar containing:
      src[0 .. from_idx)  +  insert  +  src[to_idx .. end)
  insert may be nil (no insertion).  Caller must kfree result.
  ============================================================ }
function buildSplicedString(src: pchar; from_idx, to_idx: uint32;
                            insert: pchar): pchar;
var
    src_len    : uint32;
    ins_len    : uint32;
    result_len : uint32;
    buf        : pchar;
    pos        : uint32;
begin
    src_len := stringSize(src);
    if insert <> nil then ins_len := stringSize(insert)
    else                   ins_len := 0;
    if from_idx > src_len then from_idx := src_len;
    if to_idx   > src_len then to_idx   := src_len;
    if to_idx   < from_idx then to_idx  := from_idx;
    result_len := from_idx + ins_len + (src_len - to_idx);
    buf := pchar(kalloc(result_len + 1));
    memset(uint32(buf), 0, result_len + 1);
    pos := 0;
    if from_idx > 0 then begin
        memcpy(uint32(src), uint32(buf), from_idx);
        pos := from_idx;
    end;
    if ins_len > 0 then begin
        memcpy(uint32(insert), uint32(@buf[pos]), ins_len);
        pos := pos + ins_len;
    end;
    if to_idx < src_len then
        memcpy(uint32(@src[to_idx]), uint32(@buf[pos]), src_len - to_idx);
    buildSplicedString := buf;
end;

{ ============================================================
  applyIndent
  Indent (or dedent) every line that overlaps [sel_start, sel_end)
  by 4 spaces.  Returns a new kalloc'd string.  Caller must kfree.
  ============================================================ }
function applyIndent(src: pchar; sel_start, sel_end: uint32;
                     dedent: boolean): pchar;
var
    src_len  : uint32;
    out_buf  : pchar;
    out_pos  : uint32;
    i        : uint32;
    first_ls : uint32;
    j        : uint32;
begin
    src_len := stringSize(src);
    if sel_end   > src_len then sel_end   := src_len;
    if sel_start > src_len then sel_start := src_len;

    { Find start of the line that contains sel_start }
    first_ls := sel_start;
    while (first_ls > 0) and (src[first_ls - 1] <> char(10)) do
        dec(first_ls);

    { Generous output buffer: original + 4 bytes per line (worst case ~512 lines) }
    out_buf := pchar(kalloc(src_len + 2049));
    memset(uint32(out_buf), 0, src_len + 2049);
    out_pos := 0;

    { Copy everything before the affected region verbatim }
    if first_ls > 0 then begin
        memcpy(uint32(src), uint32(out_buf), first_ls);
        out_pos := first_ls;
    end;

    { Process from first_ls onward, line by line }
    i := first_ls;
    while i <= src_len do begin
        if i = src_len then break;   { nothing left }

        if i >= sel_end then begin
            { Past the affected region: copy the remainder verbatim }
            if i < src_len then begin
                memcpy(uint32(@src[i]), uint32(@out_buf[out_pos]), src_len - i);
                out_pos := out_pos + (src_len - i);
            end;
            break;
        end;

        { Apply indent / dedent at the start of this affected line }
        if not dedent then begin
            out_buf[out_pos]     := ' ';
            out_buf[out_pos + 1] := ' ';
            out_buf[out_pos + 2] := ' ';
            out_buf[out_pos + 3] := ' ';
            out_pos := out_pos + 4;
        end else begin
            { Strip up to 4 leading spaces }
            j := 0;
            while (j < 4) and (i < src_len) and (src[i] = ' ') do begin
                inc(i);
                inc(j);
            end;
        end;

        { Copy the rest of the line up to and including the newline }
        while i < src_len do begin
            out_buf[out_pos] := src[i];
            inc(out_pos);
            if src[i] = char(10) then begin
                inc(i);
                break;
            end;
            inc(i);
        end;
    end;

    out_buf[out_pos] := char(0);
    applyIndent := out_buf;
end;

{ ============================================================
  computeLineCol
  Calculate 1-based line and column numbers for a byte offset.
  ============================================================ }
procedure computeLineCol(src: pchar; byte_pos: uint32;
                         var line_out, col_out: uint32);
var
    i    : uint32;
    line : uint32;
    col  : uint32;
    len  : uint32;
begin
    line := 1;
    col  := 1;
    len  := stringSize(src);
    if byte_pos > len then byte_pos := len;
    i := 0;
    while i < byte_pos do begin
        if src[i] = char(10) then begin
            inc(line);
            col := 1;
        end else
            inc(col);
        inc(i);
    end;
    line_out := line;
    col_out  := col;
end;

{ ============================================================
  freeState — release all kalloc'd fields and the record itself.
  ============================================================ }
procedure freeState(state: PNotepadState);
begin
    if state = nil then exit;
    if state^.ta <> nil then lv_group_remove_obj(state^.ta);
    if state^.currentPath <> nil then kfree(void(state^.currentPath));
    kfree(void(state));
end;

{ ============================================================
  Instance management helpers
  ============================================================ }
function findStateByWid(wid: uint32): PNotepadState;
var i: uint32;
begin
    findStateByWid := nil;
    if g_inst_count > 0 then
        for i := 0 to g_inst_count - 1 do
            if (g_instances[i] <> nil) and (g_instances[i]^.win_id = wid) then begin
                findStateByWid := g_instances[i];
                exit;
            end;
end;

procedure addInstance(state: PNotepadState);
begin
    if g_inst_count < MAX_NOTEPAD_INST then begin
        g_instances[g_inst_count] := state;
        inc(g_inst_count);
    end;
end;

procedure removeInstance(state: PNotepadState);
var i, j: uint32;
begin
    if g_inst_count > 0 then
        for i := 0 to g_inst_count - 1 do
            if g_instances[i] = state then begin
                { Shift remaining entries down }
                if i + 1 < g_inst_count then
                    for j := i to g_inst_count - 2 do
                        g_instances[j] := g_instances[j + 1];
                dec(g_inst_count);
                g_instances[g_inst_count] := nil;
                exit;
            end;
end;

{ ============================================================
  notepad_entry — lightweight process entry
  ============================================================ }
procedure notepad_entry(ctx : PProcessContext);
begin
    while (ctx^.State <> psFinished) and (ctx^.PendingMsg <> smKill) and (ctx^.PendingMsg <> smTerminate) do
        proc.mgr.proc_yield;
end;

{ ============================================================
  doCloseWindow — unconditionally destroy a specific instance.
  Called by discard-confirm dialogs and by onClose when clean.
  ============================================================ }
procedure doCloseWindow(state: PNotepadState);
var wid : uint32;
begin
    if state = nil then exit;
    wid := state^.win_id;
    removeInstance(state);
    if state^.pid <> 0 then begin
        proc.mgr.kill(state^.pid);
        state^.pid := 0;
    end;
    if state^.ta <> nil then lv_group_remove_obj(state^.ta);
    state^.ta := nil;
    driver.video.windows.destroyWindow(wid);
    freeState(state);
end;

{ ============================================================
  updateStatusBar
  ============================================================ }
procedure updateStatusBar(state: PNotepadState);
var
    txt         : pchar;
    cpos        : uint32;
    line, col   : uint32;
    s1, s2, s3  : pchar;
begin
    if (state = nil) or (state^.status_label = nil) then exit;
    txt  := lv_textarea_get_text(state^.ta);
    cpos := lv_textarea_get_cursor_pos(state^.ta);
    computeLineCol(txt, cpos, line, col);

    s1 := intToString(line);
    s2 := stringConcat('Ln ', s1);
    kfree(void(s1));
    s1 := intToString(col);
    s3 := stringConcat(s2, stringConcat('  Col ', s1));
    kfree(void(s2));
    kfree(void(s1));

    if state^.currentPath <> nil then
        s1 := stringConcat('    ', state^.currentPath)
    else
        s1 := stringCopy('    Untitled');
    s2 := stringConcat(s3, s1);
    kfree(void(s3));
    kfree(void(s1));

    lv_label_set_text(state^.status_label, s2);
    kfree(void(s2));

    if state^.isDirty then
        lv_label_set_text(state^.dirty_label, '*')
    else
        lv_label_set_text(state^.dirty_label, '');
end;

{ ============================================================
  saveFile
  ============================================================ }
procedure saveFile(state: PNotepadState);
var
    fHandle : driver.storage.vfs.TFileHandle;
    fError  : driver.storage.types.TError;
    txt     : pchar;
    buf     : pchar;
    len     : uint32;
    written : uint32;
    s1, s2  : pchar;
begin
    debug.tracer.push_trace('notepad.saveFile');
    if state^.currentPath = nil then begin
        app.filepicker.show_save('Save As', '/disk', nil, nil, @np_saveas_done_cb, state);
        debug.tracer.pop_trace;
        exit;
    end;
    { Show Saving... immediately for feedback before the blocking I/O call }
    lv_label_set_text(state^.status_label, 'Saving...');
    txt := lv_textarea_get_text(state^.ta);
    len := stringSize(txt);
    if len > FILE_BUF_SIZE - 1 then len := FILE_BUF_SIZE - 1;
    buf := pchar(kalloc(FILE_BUF_SIZE));
    memset(uint32(buf), 0, FILE_BUF_SIZE);
    memcpy(uint32(txt), uint32(buf), len);
    fHandle := driver.storage.vfs.OpenFile(state^.currentPath, omReadWrite, @fError);
    if fHandle = 0 then
        fHandle := driver.storage.vfs.OpenFile(state^.currentPath, omCreate, @fError);
    if fHandle = 0 then begin
        kfree(void(buf));
        io.syslog.logln('NOTEPAD', 'saveFile: OpenFile failed');
        showErrorMsgbox('Save Failed', 'Could not open file for writing.');
        updateStatusBar(state);
        debug.tracer.pop_trace;
        exit;
    end;
    written := driver.storage.vfs.WriteFile(fHandle, 0, puint8(buf), len);
    driver.storage.vfs.CloseFile(fHandle);
    kfree(void(buf));
    if written <> len then begin
        io.syslog.logln('NOTEPAD', 'saveFile: WriteFile returned 0');
        showErrorMsgbox('Save Failed', 'File write failed. Check filesystem.');
        updateStatusBar(state);
        debug.tracer.pop_trace;
        exit;
    end;
    state^.isDirty := false;
    s1 := stringCopy('Saved: ');
    s2 := stringConcat(s1, state^.currentPath);
    kfree(void(s1));
    lv_label_set_text(state^.status_label, s2);
    kfree(void(s2));
    lv_label_set_text(state^.dirty_label, '');
    debug.tracer.pop_trace;
end;

{ ============================================================
  loadFile
  ============================================================ }
procedure loadFile(state: PNotepadState; path: pchar);
var
    fHandle : driver.storage.vfs.TFileHandle;
    fError  : driver.storage.types.TError;
    buf     : pchar;
begin
    debug.tracer.push_trace('notepad.loadFile');
    fHandle := driver.storage.vfs.OpenFile(path, omRead, @fError);
    if (fHandle = 0) or (fError <> eNone) then begin
        io.syslog.logln('NOTEPAD', 'loadFile: could not open file');
        showErrorMsgbox('Open Failed', 'Could not open file for reading.');
        debug.tracer.pop_trace;
        exit;
    end;
    buf := pchar(kalloc(FILE_BUF_SIZE));
    memset(uint32(buf), 0, FILE_BUF_SIZE);
    driver.storage.vfs.ReadFile(fHandle, 0, puint8(buf), FILE_BUF_SIZE - 1);
    driver.storage.vfs.CloseFile(fHandle);
    if state^.currentPath <> nil then kfree(void(state^.currentPath));
    state^.currentPath := stringCopy(path);
    lv_textarea_set_text(state^.ta, buf);
    { lv_textarea_set_text fires VALUE_CHANGED which marks dirty — reset it }
    state^.isDirty := false;
    lv_textarea_clear_selection(state^.ta);
    state^.sel_anchor := -1;
    lv_textarea_set_cursor_pos(state^.ta, 0);
    updateStatusBar(state);
    kfree(void(buf));
    debug.tracer.pop_trace;
end;

{ ============================================================
  performNew — clear buffer and reset path
  ============================================================ }
procedure performNew(state: PNotepadState);
begin
    lv_textarea_set_text(state^.ta, '');
    state^.isDirty := false;
    state^.sel_anchor := -1;
    lv_textarea_clear_selection(state^.ta);
    if state^.currentPath <> nil then begin
        kfree(void(state^.currentPath));
        state^.currentPath := nil;
    end;
    updateStatusBar(state);
end;

{ ============================================================
  Discard-confirmation msgbox callbacks
  ============================================================ }

{ Generic cancel: just close the msgbox (passed as user_data) }
procedure mbox_cancel_cb(e: Plv_event); cdecl;
var
    code : lv_event_code_t;
    mbox : Plv_obj;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_CLICKED then exit;
    mbox := Plv_obj(lv_event_get_user_data(e));
    lv_obj_delete(mbox);
end;

{ Discard + close window }
procedure mbox_close_discard_cb(e: Plv_event); cdecl;
var
    code  : lv_event_code_t;
    mbox  : Plv_obj;
    state : PNotepadState;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_CLICKED then exit;
    mbox  := Plv_obj(lv_event_get_user_data(e));
    state := PNotepadState(lv_obj_get_user_data(mbox));
    lv_obj_delete(mbox);
    doCloseWindow(state);
end;

{ Discard + new document }
procedure mbox_new_discard_cb(e: Plv_event); cdecl;
var
    code  : lv_event_code_t;
    mbox  : Plv_obj;
    state : PNotepadState;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_CLICKED then exit;
    mbox  := Plv_obj(lv_event_get_user_data(e));
    state := PNotepadState(lv_obj_get_user_data(mbox));
    lv_obj_delete(mbox);
    if state <> nil then performNew(state);
end;

{ ============================================================
  showDiscardMsgbox — generic "Unsaved changes / Discard?" dialog.
  discard_cb receives the mbox pointer as user_data.
  ============================================================ }
procedure showDiscardMsgbox(discard_cb: lv_event_cb_t; state: PNotepadState);
var
    mbox      : Plv_obj;
    scr       : Plv_obj;
    discard_b : Plv_obj;
    cancel_b  : Plv_obj;
begin
    scr       := lv_screen_active;
    mbox      := lv_msgbox_create(scr);
    lv_msgbox_add_title(mbox, 'Unsaved Changes');
    lv_msgbox_add_close_button(mbox);
    { Store owner state in mbox user_data so callbacks can retrieve it }
    lv_obj_set_user_data(mbox, state);
    cancel_b  := lv_msgbox_add_footer_button(mbox, 'Cancel');
    discard_b := lv_msgbox_add_footer_button(mbox, 'Discard');
    lv_obj_add_event_cb(discard_b, discard_cb,      LV_EVENT_CLICKED, mbox);
    lv_obj_add_event_cb(cancel_b,  @mbox_cancel_cb, LV_EVENT_CLICKED, mbox);
end;

{ ============================================================
  showErrorMsgbox — modal error dialog with OK button
  ============================================================ }
procedure showErrorMsgbox(title: pchar; msg: pchar);
var
    mbox : Plv_obj;
    ok_b : Plv_obj;
begin
    mbox := lv_msgbox_create(lv_screen_active);
    lv_msgbox_add_title(mbox, title);
    lv_msgbox_add_text(mbox, msg);
    ok_b := lv_msgbox_add_footer_button(mbox, 'OK');
    lv_obj_add_event_cb(ok_b, @mbox_cancel_cb, LV_EVENT_CLICKED, mbox);
end;

{ ============================================================
  File picker done callbacks
  ============================================================ }

procedure np_open_done_cb(path: pchar; userdata: pointer); cdecl;
var
    state: PNotepadState;
begin
    state := PNotepadState(userdata);
    if (path = nil) or (state = nil) then begin
        if path <> nil then kfree(void(path));
        exit;
    end;
    loadFile(state, path);
    kfree(void(path));
end;

procedure np_saveas_done_cb(path: pchar; userdata: pointer); cdecl;
var
    state: PNotepadState;
begin
    state := PNotepadState(userdata);
    if (path = nil) or (state = nil) then begin
        if path <> nil then kfree(void(path));
        exit;
    end;
    if state^.currentPath <> nil then kfree(void(state^.currentPath));
    state^.currentPath := stringCopy(path);
    kfree(void(path));
    saveFile(state);
end;

{ ============================================================
  Toolbar callbacks
  ============================================================ }

procedure new_btn_cb(e: Plv_event); cdecl;
var
    code  : lv_event_code_t;
    state : PNotepadState;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_CLICKED then exit;
    state := PNotepadState(lv_event_get_user_data(e));
    if state = nil then exit;
    if state^.isDirty then
        showDiscardMsgbox(@mbox_new_discard_cb, state)
    else
        performNew(state);
end;

procedure open_btn_cb(e: Plv_event); cdecl;
var
    code  : lv_event_code_t;
    state : PNotepadState;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_CLICKED then exit;
    state := PNotepadState(lv_event_get_user_data(e));
    if state = nil then exit;
    app.filepicker.show_open('Open File', '/disk', nil, @np_open_done_cb, state);
end;

procedure save_btn_cb(e: Plv_event); cdecl;
var
    code  : lv_event_code_t;
    state : PNotepadState;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_CLICKED then exit;
    state := PNotepadState(lv_event_get_user_data(e));
    if state = nil then exit;
    saveFile(state);
end;

procedure saveas_btn_cb(e: Plv_event); cdecl;
var
    code  : lv_event_code_t;
    state : PNotepadState;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_CLICKED then exit;
    state := PNotepadState(lv_event_get_user_data(e));
    if state = nil then exit;
    app.filepicker.show_save('Save As', '/disk', nil, nil, @np_saveas_done_cb, state);
end;

{ ============================================================
  Main textarea — key handler
  User callbacks fire BEFORE the widget default handler.
  We call stopEvent(e) for every key we handle ourselves so
  LVGL does not also act on it.
  ============================================================ }
procedure ta_key_cb(e: Plv_event); cdecl;
var
    code     : lv_event_code_t;
    state    : PNotepadState;
    key      : uint32;
    ta       : Plv_obj;
    lbl      : Plv_obj;
    curr_pos : uint32;
    new_pos  : uint32;
    anchor   : uint32;
    sel_s    : uint32;
    sel_e    : uint32;
    src      : pchar;
    new_text : pchar;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_KEY then exit;
    state := PNotepadState(lv_event_get_user_data(e));
    if state = nil then exit;
    ta       := state^.ta;
    lbl      := lv_textarea_get_label(ta);
    key      := lv_event_get_key(e);
    curr_pos := lv_textarea_get_cursor_pos(ta);

    { ---- Ctrl+S: save ---- }
    if driver.hid.keyboard.is_ctrl and (key = ord('s')) then begin
        saveFile(state);
        stopEvent(e);
        exit;
    end;

    { ---- Ctrl+A: select all ---- }
    if driver.hid.keyboard.is_ctrl and (key = ord('a')) then begin
        src := lv_textarea_get_text(ta);
        state^.sel_anchor := 0;
        lv_label_set_text_selection_start(lbl, 0);
        lv_label_set_text_selection_end(lbl, stringSize(src));
        lv_textarea_set_cursor_pos(ta, LV_CURSOR_LAST);
        stopEvent(e);
        exit;
    end;

    { ---- Plain arrow keys (no Shift): clear any existing selection ---- }
    if (not driver.hid.keyboard.is_shift) and
       ((key = LV_KEY_LEFT)  or (key = LV_KEY_RIGHT) or
        (key = LV_KEY_UP)    or (key = LV_KEY_DOWN)) then begin
        if state^.sel_anchor <> -1 then begin
            state^.sel_anchor := -1;
            lv_textarea_clear_selection(ta);
        end;
        { Let LVGL handle cursor movement — do NOT call stopEvent }
        exit;
    end;

    { ---- Home / End: clear selection, let LVGL handle position ---- }
    if (key = LV_KEY_HOME) or (key = LV_KEY_END) then begin
        state^.sel_anchor := -1;
        lv_textarea_clear_selection(ta);
        exit;
    end;

    { ---- Shift+Arrow: extend / create selection ---- }
    if driver.hid.keyboard.is_shift and
       ((key = LV_KEY_LEFT)  or (key = LV_KEY_RIGHT) or
        (key = LV_KEY_UP)    or (key = LV_KEY_DOWN)) then begin
        { Initialise anchor on first Shift+Arrow }
        if state^.sel_anchor = -1 then
            state^.sel_anchor := sint32(curr_pos);
        { Move cursor ourselves so we get the updated position }
        case key of
            LV_KEY_LEFT  : lv_textarea_cursor_left(ta);
            LV_KEY_RIGHT : lv_textarea_cursor_right(ta);
            LV_KEY_UP    : lv_textarea_cursor_up(ta);
            LV_KEY_DOWN  : lv_textarea_cursor_down(ta);
        end;
        new_pos := lv_textarea_get_cursor_pos(ta);
        anchor  := uint32(state^.sel_anchor);
        if new_pos < anchor then begin
            lv_label_set_text_selection_start(lbl, new_pos);
            lv_label_set_text_selection_end(lbl, anchor);
        end else begin
            lv_label_set_text_selection_start(lbl, anchor);
            lv_label_set_text_selection_end(lbl, new_pos);
        end;
        { Stop LVGL from also moving the cursor (would double-move) }
        stopEvent(e);
        exit;
    end;

    { ---- Backspace / Del with active selection: delete the selection ---- }
    if ((key = LV_KEY_BACKSPACE) or (key = LV_KEY_DEL)) and
       (state^.sel_anchor <> -1) then begin
        anchor := uint32(state^.sel_anchor);
        if anchor < curr_pos then begin
            sel_s := anchor;
            sel_e := curr_pos;
        end else begin
            sel_s := curr_pos;
            sel_e := anchor;
        end;
        src      := lv_textarea_get_text(ta);
        new_text := buildSplicedString(src, sel_s, sel_e, nil);
        lv_textarea_set_text(ta, new_text);
        kfree(void(new_text));
        lv_textarea_set_cursor_pos(ta, sint32(sel_s));
        state^.sel_anchor := -1;
        lv_textarea_clear_selection(ta);
        state^.isDirty := true;
        updateStatusBar(state);
        stopEvent(e);   { prevent LVGL from also deleting one more char }
        exit;
    end;

    { ---- Tab key ---- }
    if key = LV_KEY_NEXT then begin
        if state^.sel_anchor <> -1 then begin
            { Indent or dedent the selected lines }
            anchor := uint32(state^.sel_anchor);
            if anchor < curr_pos then begin
                sel_s := anchor;
                sel_e := curr_pos;
            end else begin
                sel_s := curr_pos;
                sel_e := anchor;
            end;
            src      := lv_textarea_get_text(ta);
            new_text := applyIndent(src, sel_s, sel_e, driver.hid.keyboard.is_shift);
            lv_textarea_set_text(ta, new_text);
            kfree(void(new_text));
            state^.sel_anchor := -1;
            lv_textarea_clear_selection(ta);
            state^.isDirty := true;
            updateStatusBar(state);
        end else begin
            { No selection: insert 4 spaces }
            lv_textarea_add_text(ta, '    ');
        end;
        stopEvent(e);   { prevent LVGL from inserting a raw tab char }
        exit;
    end;

    { ---- Any other key with selection active: clear selection, let LVGL type ---- }
    if state^.sel_anchor <> -1 then begin
        state^.sel_anchor := -1;
        lv_textarea_clear_selection(ta);
    end;
end;

{ ============================================================
  Main textarea — VALUE_CHANGED (dirty tracking + status bar)
  ============================================================ }
procedure ta_changed_cb(e: Plv_event); cdecl;
var
    code  : lv_event_code_t;
    state : PNotepadState;
begin
    code := lv_event_get_code(e);
    if code <> LV_EVENT_VALUE_CHANGED then exit;
    state := PNotepadState(lv_event_get_user_data(e));
    if state = nil then exit;
    state^.isDirty := true;
    updateStatusBar(state);
end;

{ ============================================================
  makeToolBtn — compact toolbar button helper
  ============================================================ }
function makeToolBtn(parent: Plv_obj; text: pchar; w: sint32;
                     state_ptr: PNotepadState;
                     cb: lv_event_cb_t): Plv_obj;
var
    btn, lbl_obj : Plv_obj;
begin
    btn := lv_button_create(parent);
    lv_obj_remove_style_all(btn);
    lv_obj_set_size(btn, w, 30);
    lv_obj_set_style_bg_color(btn, lv_color_make(45, 50, 68), 0);
    lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, 0);
    lv_obj_set_style_radius(btn, 4, 0);
    lv_obj_add_flag(btn, LV_OBJ_FLAG_CLICKABLE);
    lv_obj_set_style_layout(btn, LV_LAYOUT_FLEX, 0);
    lv_obj_set_flex_flow(btn, LV_FLEX_FLOW_ROW);
    lv_obj_set_flex_align(btn, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER,
                          LV_FLEX_ALIGN_CENTER);
    lbl_obj := lv_label_create(btn);
    lv_label_set_text(lbl_obj, text);
    lv_obj_set_style_text_color(lbl_obj, lv_color_make(210, 215, 230), 0);
    lv_obj_set_style_text_font(lbl_obj, @lv_font_montserrat_14, 0);
    lv_obj_add_event_cb(btn, cb, LV_EVENT_CLICKED, state_ptr);
    makeToolBtn := btn;
end;

{ ============================================================
  onClose — called by the driver.video.windows unit when the X button is pressed
  ============================================================ }
procedure onClose(wid: uint32);
var state : PNotepadState;
begin
    debug.tracer.push_trace('notepad.onClose');
    state := findStateByWid(wid);
    if state = nil then begin debug.tracer.pop_trace; exit; end;
    if state^.isDirty then begin
        showDiscardMsgbox(@mbox_close_discard_cb, state);
        debug.tracer.pop_trace;
        exit;
    end;
    doCloseWindow(state);
    debug.tracer.pop_trace;
end;

{ ============================================================
  launch — create the window and populate the UI
  ============================================================ }
{ ============================================================
  launchInstance — create a new notepad window; returns the
  state pointer or nil on failure.
  ============================================================ }
function launchInstance: PNotepadState;
var
    scr_w, scr_h : sint32;
    wx, wy       : sint32;
    content      : Plv_obj;
    toolbar      : Plv_obj;
    statusbar    : Plv_obj;
    ta           : Plv_obj;
    sl    : Plv_obj;
    dl    : Plv_obj;
    state : PNotepadState;
    ctx   : PProcessContext;
    wid   : uint32;
begin
    debug.tracer.push_trace('notepad.launchInstance');
    launchInstance := nil;

    if g_inst_count >= MAX_NOTEPAD_INST then begin
        debug.tracer.pop_trace; exit;
    end;

    scr_w := sint32(driver.video.frontBufferWidth);
    scr_h := sint32(driver.video.frontBufferHeight);
    wx    := (scr_w - WIN_W) div 2 + sint32(g_inst_count) * 30;
    wy    := (scr_h - WIN_H) div 2 - 30 + sint32(g_inst_count) * 30;

    wid := driver.video.windows.createWindow('Notepad', wx, wy, WIN_W, WIN_H,
                                   @onClose, nil);
    if wid = 0 then begin
        debug.tracer.pop_trace; exit;
    end;

    content := driver.video.windows.getWindowContent(wid);
    if content = nil then begin
        driver.video.windows.destroyWindow(wid);
        debug.tracer.pop_trace; exit;
    end;

    { Allocate and zero-initialise state }
    state := PNotepadState(kalloc(sizeof(TNotepadState)));
    memset(uint32(state), 0, sizeof(TNotepadState));
    state^.win_id     := wid;
    state^.sel_anchor := -1;
    addInstance(state);

    { ---- Content area: flex column ---- }
    lv_obj_set_style_layout(content, LV_LAYOUT_FLEX, 0);
    lv_obj_set_flex_flow(content, LV_FLEX_FLOW_COLUMN);
    lv_obj_set_style_pad_all(content, 0, 0);
    lv_obj_set_style_pad_row(content, 0, 0);
    lv_obj_remove_flag(content, LV_OBJ_FLAG_SCROLLABLE);
    lv_obj_set_style_bg_color(content, lv_color_make(28, 31, 40), 0);
    lv_obj_set_style_bg_opa(content, LV_OPA_COVER, 0);

    { ---- Toolbar ---- }
    toolbar := lv_obj_create(content);
    lv_obj_remove_style_all(toolbar);
    lv_obj_set_size(toolbar, lv_pct(100), TOOLBAR_H);
    lv_obj_set_style_bg_color(toolbar, lv_color_make(28, 31, 40), 0);
    lv_obj_set_style_bg_opa(toolbar, LV_OPA_COVER, 0);
    lv_obj_set_style_border_color(toolbar, lv_color_make(48, 52, 68), 0);
    lv_obj_set_style_border_side(toolbar, LV_BORDER_SIDE_BOTTOM, 0);
    lv_obj_set_style_border_width(toolbar, 1, 0);
    lv_obj_set_style_pad_all(toolbar, 5, 0);
    lv_obj_set_style_pad_column(toolbar, 4, 0);
    lv_obj_set_style_layout(toolbar, LV_LAYOUT_FLEX, 0);
    lv_obj_set_flex_flow(toolbar, LV_FLEX_FLOW_ROW);
    lv_obj_set_flex_align(toolbar, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER,
                         LV_FLEX_ALIGN_CENTER);
    lv_obj_remove_flag(toolbar, LV_OBJ_FLAG_SCROLLABLE);

    { File group: New, Open, Save, Save As }
    makeToolBtn(toolbar, 'New',     58, state, @new_btn_cb);
    makeToolBtn(toolbar, 'Open',    64, state, @open_btn_cb);
    makeToolBtn(toolbar, 'Save',    58, state, @save_btn_cb);
    makeToolBtn(toolbar, 'Save As', 80, state, @saveas_btn_cb);

    { ---- Main textarea ---- }
    ta := lv_textarea_create(content);
    lv_obj_set_size(ta, lv_pct(100), 0);
    lv_obj_set_flex_grow(ta, 1);
    lv_textarea_set_text(ta, '');
    lv_textarea_set_text_selection(ta, true);
    { Background and text }
    lv_obj_set_style_bg_color(ta, lv_color_make(20, 22, 32), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(ta, LV_OPA_COVER, LV_PART_MAIN);
    lv_obj_set_style_text_color(ta, lv_color_make(210, 218, 240), LV_PART_MAIN);
    lv_obj_set_style_text_font(ta, @hack_14, LV_PART_MAIN);
    lv_obj_set_style_border_width(ta, 0, LV_PART_MAIN);
    lv_obj_set_style_radius(ta, 0, LV_PART_MAIN);
    lv_obj_set_style_pad_all(ta, 8, LV_PART_MAIN);
    { Cursor }
    lv_obj_set_style_bg_color(ta, lv_color_make(100, 160, 255), LV_PART_CURSOR);
    lv_obj_set_style_border_width(ta, 0, LV_PART_CURSOR);
    { Selection highlight }
    lv_obj_set_style_bg_color(ta, lv_color_make(55, 90, 190), LV_PART_SELECTED);
    lv_obj_set_style_bg_opa(ta, LV_OPA_COVER, LV_PART_SELECTED);
    { Register with driver.hid.keyboard group }
    lv_group_add_obj(lvgl_get_kb_group, ta);
    lv_group_focus_obj(ta);
    { Always wrap — set before attaching callbacks }
    lv_label_set_long_mode(lv_textarea_get_label(ta), LV_LABEL_LONG_WRAP);
    { Attach event callbacks (state passed as user_data) }
    lv_obj_add_event_cb(ta, @ta_key_cb,     LV_EVENT_KEY,          state);
    lv_obj_add_event_cb(ta, @ta_changed_cb, LV_EVENT_VALUE_CHANGED, state);
    state^.ta := ta;

    { ---- Status bar ---- }
    statusbar := lv_obj_create(content);
    lv_obj_remove_style_all(statusbar);
    lv_obj_set_size(statusbar, lv_pct(100), STATUSBAR_H);
    lv_obj_set_style_bg_color(statusbar, lv_color_make(28, 31, 40), 0);
    lv_obj_set_style_bg_opa(statusbar, LV_OPA_COVER, 0);
    lv_obj_set_style_border_color(statusbar, lv_color_make(48, 52, 68), 0);
    lv_obj_set_style_border_side(statusbar, LV_BORDER_SIDE_TOP, 0);
    lv_obj_set_style_border_width(statusbar, 1, 0);
    lv_obj_set_style_layout(statusbar, LV_LAYOUT_FLEX, 0);
    lv_obj_set_flex_flow(statusbar, LV_FLEX_FLOW_ROW);
    lv_obj_set_flex_align(statusbar, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER,
                         LV_FLEX_ALIGN_CENTER);
    lv_obj_set_style_pad_left(statusbar, 8, 0);
    lv_obj_remove_flag(statusbar, LV_OBJ_FLAG_SCROLLABLE);

    sl := lv_label_create(statusbar);
    lv_label_set_text(sl, 'Ln 1  Col 1    Untitled');
    lv_obj_set_style_text_color(sl, lv_color_make(140, 150, 170), 0);
    lv_obj_set_style_text_font(sl, @lv_font_montserrat_14, 0);
    state^.status_label := sl;

    dl := lv_label_create(statusbar);
    lv_label_set_text(dl, '');
    lv_obj_set_style_text_color(dl, lv_color_make(255, 180, 60), 0);
    lv_obj_set_style_text_font(dl, @lv_font_montserrat_14, 0);
    state^.dirty_label := dl;

    { Create process so app.notepad appears in PS and is manageable }
    ctx := proc.mgr.create('Notepad', @notepad_entry, void(state), 1);
    if ctx <> nil then begin
        state^.pid := ctx^.ProcessID;
        driver.video.windows.setWindowOwner(wid, ctx^.ProcessID);
    end;

    launchInstance := state;
    debug.tracer.pop_trace;
end;

{ launch — desktop-launcher callback; creates a new empty notepad window }
procedure launch;
begin
    launchInstance;
end;

{ ============================================================
  File dispatch support
  ============================================================ }

{ Poll timer — runs in LVGL context, checks for deferred file opens }
procedure notepad_dispatch_poll(tmr: Plv_timer); cdecl;
var
    path  : pchar;
    state : PNotepadState;
begin
    if puint32(@g_dispatch_pending)^ <> 1 then exit;
    puint32(@g_dispatch_pending)^ := 0;

    path := g_dispatch_path;
    g_dispatch_path := nil;
    if path = nil then exit;

    { Always open a new window for dispatched files }
    state := launchInstance;
    if state <> nil then
        loadFile(state, path);

    kfree(void(path));
end;

{ Handler callback — called by driver.storage.filedispatch from
  any process context (typically the file-browser worker).
  We cannot call LVGL directly (Lesson #15), so we store the path
  and let the poll timer pick it up in LVGL context. }
function notepad_file_handler(path : pchar;
                              params : PParamList;
                              stdin_buf, stdout_buf, stderr_buf : POutBuf) : uint32;
begin
    debug.tracer.push_trace('notepad.file_handler');
    notepad_file_handler := 0;

    { If a dispatch is already pending, reject to avoid leaking the path }
    if puint32(@g_dispatch_pending)^ = 1 then begin
        debug.tracer.pop_trace;
        exit;
    end;

    g_dispatch_path := stringCopy(path);
    puint32(@g_dispatch_pending)^ := 1;

    { Return 1 to signal "handled — UI will open asynchronously" }
    notepad_file_handler := 1;
    debug.tracer.pop_trace;
end;

{ ============================================================
  init — register with the driver.video.desktop program launcher
         and with the file dispatch system for text extensions
  ============================================================ }
procedure init();
begin
    debug.tracer.push_trace('notepad.init');
    g_inst_count := 0;
    g_dispatch_path    := nil;
    g_dispatch_pending := 0;

    driver.video.desktop.registerProgram('Notepad', @launch);

    { Register as the handler for common text-file extensions }
    driver.storage.filedispatch.registerExtHandler(
        '.txt,.md,.log,.cfg,.ini,.json,.xml,.yml,.yaml,.csv,.pas,.inc,.c,.h,.cpp,.py,.js,.ts,.sh,.bat,.conf,.toml',
        'Text',
        @notepad_file_handler);

    { Create a 100ms poll timer for deferred file-dispatch opens }
    g_dispatch_timer := lv_timer_create(@notepad_dispatch_poll, 100, nil);

    debug.tracer.pop_trace;
end;

end.