/*
 * penpad_fb2.c
 *
 * Simple native notepad for Kindle Scribe:
 * - Reads stylus events from /dev/input/stylus
 * - Draws into an 8bpp /dev/fb0 framebuffer
 * - Maintains a 1-bit offscreen bitmap (g_bitmap) for PBM export
 * - Also exports PNG via LodePNG from the same bitmap
 * - Double-tap gestures:
 *      top-left      = save (PBM + PNG) to /mnt/us/simple_notes
 *      top-right     = exit
 *      bottom-right  = reset page (clear) without saving
 * - Optional: load a P1 PBM passed as argv[1] into framebuffer + g_bitmap
 *
 * Coordinate mapping:
 * - Stylus X: RAW_X_MIN..RAW_X_MAX mapped to 0..(g_fb_width-1), reversed axis
 * - Stylus Y: RAW_Y_MIN..RAW_Y_MAX mapped to 0..(g_fb_height-1), inverted axis
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/time.h>
#include <linux/fb.h>

// ---- LodePNG for PNG export ----
#include "lodepng.h"

// DEV devices
#define DEV_PATH_STYLUS "/dev/input/stylus"
#define DEV_PATH_TOUCH  "/dev/input/touch"
#define DEV_PATH_FB     "/dev/fb0"

// Path definitions
#define US_HOME_PATH    "/mnt/us/extensions/simplenotes"
#define US_SAVE_PATH    "/mnt/us/simplenotes"

// Raw stylus ranges (from full calibration)
#define RAW_X_MIN  0
#define RAW_X_MAX  15624   // left ~15624, right ~0
#define RAW_Y_MIN  0
#define RAW_Y_MAX  20832   // top ~20832, bottom ~0


// Stroke thickness in pixels
#define STROKE_PX 3

// Height of the top/bottom gesture bar in pixels
#define TOPBAR_H 100

// Refresh interval in ms
#define REFRESH_INTERVAL_MS 45

// Double-tap window and feedback delay
#define DOUBLE_TAP_WINDOW_SEC     2
#define SAVE_FEEDBACK_SLEEP_SEC   1

// ============================================================================
// Framebuffer context
// ============================================================================

typedef struct {
    int fd;
    struct fb_fix_screeninfo finfo;
    struct fb_var_screeninfo vinfo;
    uint8_t *fbp;
    size_t screensize;
} fb_ctx_t;

// ============================================================================
// Global drawing / state
// ============================================================================

static uint8_t *g_bitmap = NULL;   // 1-bit (stored as bytes) full-screen: 1=black, 0=white
static int g_fb_width = 0;
static int g_fb_height = 0;

typedef enum {
    TAP_NONE = 0,
    TAP_LEFT,
    TAP_RIGHT,
    TAP_BOTTOM_RIGHT
} tap_zone_t;

static tap_zone_t g_last_tap_zone = TAP_NONE;
static int g_tap_count = 0;
static time_t g_last_tap_timestamp = 0;

// ============================================================================
// Time helpers
// ============================================================================

static uint64_t now_ms(void) {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (uint64_t)tv.tv_sec * 1000ULL + tv.tv_usec / 1000ULL;
}

// ============================================================================
// Framebuffer helpers
// ============================================================================

static void framebuffer_clear_white(uint8_t *fbp, long screensize) {
    memset(fbp, 0xFF, screensize);   // white = 0xFF
}

// Initialize framebuffer context for /dev/fb0:
// - opens device
// - mmaps framebuffer to ctx->fbp
// - clears screen to white
// - allocates 1-bit g_bitmap backing store
static int fb_init(fb_ctx_t *ctx, const char *path) {
    memset(ctx, 0, sizeof(*ctx));
    ctx->fd = open(path, O_RDWR);
    if (ctx->fd < 0) {
        perror("open fb");
        return -1;
    }
    if (ioctl(ctx->fd, FBIOGET_FSCREENINFO, &ctx->finfo) < 0) {
        perror("FBIOGET_FSCREENINFO");
        close(ctx->fd);
        ctx->fd = -1;
        return -1;
    }
    if (ioctl(ctx->fd, FBIOGET_VSCREENINFO, &ctx->vinfo) < 0) {
        perror("FBIOGET_VSCREENINFO");
        close(ctx->fd);
        ctx->fd = -1;
        return -1;
    }
    ctx->screensize = ctx->finfo.line_length * ctx->vinfo.yres;
    ctx->fbp = mmap(NULL, ctx->screensize, PROT_READ | PROT_WRITE,
                    MAP_SHARED, ctx->fd, 0);
    if (ctx->fbp == MAP_FAILED) {
        perror("mmap fb");
        ctx->fbp = NULL;
        close(ctx->fd);
        ctx->fd = -1;
        return -1;
    }

    // Initial blank overlay: clear whole framebuffer to white once
    framebuffer_clear_white(ctx->fbp, ctx->screensize);
    msync(ctx->fbp, ctx->screensize, MS_SYNC);

    fprintf(stderr, "fb: %ux%u, bpp=%u, line_length=%u\n",
            ctx->vinfo.xres, ctx->vinfo.yres,
            ctx->vinfo.bits_per_pixel, ctx->finfo.line_length);

    if (ctx->vinfo.bits_per_pixel != 8) {
        fprintf(stderr, "WARNUNG: bits_per_pixel != 8, Code erwartet 8bpp!\n");
    }

    g_fb_width  = ctx->vinfo.xres;
    g_fb_height = ctx->vinfo.yres;

    g_bitmap = calloc(g_fb_width * g_fb_height, 1);
    if (!g_bitmap) {
        perror("calloc bitmap");
        munmap(ctx->fbp, ctx->screensize);
        ctx->fbp = NULL;
        close(ctx->fd);
        ctx->fd = -1;
        return -1;
    }

    return 0;
}

// Clear framebuffer and logical bitmap
static void fb_clear(fb_ctx_t *ctx, uint8_t value) {
    if (!ctx->fbp) return;
    memset(ctx->fbp, value, ctx->screensize);
    if (g_bitmap) {
        memset(g_bitmap, 0, g_fb_width * g_fb_height);
    }
}

static void fb_close(fb_ctx_t *ctx) {
    if (g_bitmap) {
        free(g_bitmap);
        g_bitmap = NULL;
    }

    if (ctx->fbp && ctx->fbp != MAP_FAILED) {
        munmap(ctx->fbp, ctx->screensize);
        ctx->fbp = NULL;
    }
    if (ctx->fd >= 0) {
        close(ctx->fd);
        ctx->fd = -1;
    }
}

// Global eInk refresh
static void fb_flush(void) {
    system("eips -r 2>/dev/null");
}

// ============================================================================
// Drawing primitives
// ============================================================================

// Set a single pixel in framebuffer + g_bitmap
static void fb_set_pixel(fb_ctx_t *ctx, int x, int y, uint8_t value) {
    if (!ctx->fbp) return;
    if (x < 0 || x >= g_fb_width || y < 0 || y >= g_fb_height) return;

    size_t offset = (size_t)y * ctx->finfo.line_length + (size_t)x;
    if (offset >= ctx->screensize) return;
    ctx->fbp[offset] = value;

    if (g_bitmap) {
        size_t idx = (size_t)y * g_fb_width + (size_t)x;
        if (idx < (size_t)g_fb_width * g_fb_height) {
            g_bitmap[idx] = (value == 0x00) ? 1 : 0;
        }
    }
}

// Draw a thick block around (cx, cy) more efficiently
static void fb_draw_thick_point(fb_ctx_t *ctx, int cx, int cy, uint8_t value) {
    if (!ctx || !ctx->fbp) return;

    // Fast path: 1-pixel stroke → behave exactly like before
    if (STROKE_PX <= 1) {
        fb_set_pixel(ctx, cx, cy, value);
        return;
    }

    int half = STROKE_PX / 2;

    int x0 = cx - half;
    int x1 = cx + half;
    int y0 = cy - half;
    int y1 = cy + half;

    // Completely outside the screen?
    if (x1 < 0 || x0 >= g_fb_width || y1 < 0 || y0 >= g_fb_height) {
        return;
    }

    // Clamp to framebuffer bounds
    if (x0 < 0)             x0 = 0;
    if (y0 < 0)             y0 = 0;
    if (x1 >= g_fb_width)   x1 = g_fb_width  - 1;
    if (y1 >= g_fb_height)  y1 = g_fb_height - 1;

    const size_t total_bits = (size_t)g_fb_width * g_fb_height;

    for (int y = y0; y <= y1; ++y) {
        // Framebuffer row start
        size_t fb_off = (size_t)y * ctx->finfo.line_length + (size_t)x0;
        if (fb_off >= ctx->screensize) {
            // Safety; should not happen after clamping
            break;
        }

        uint8_t *fb_row = ctx->fbp + fb_off;

        // Bitmap row start
        size_t bmp_idx = (size_t)y * g_fb_width + (size_t)x0;

        for (int x = x0; x <= x1; ++x) {
            *fb_row++ = value;

            if (g_bitmap && bmp_idx < total_bits) {
                // Keep same semantics as fb_set_pixel: 0x00 = black = 1
                g_bitmap[bmp_idx] = (value == 0x00) ? 1 : 0;
            }
            ++bmp_idx;
        }
    }
}


// Bresenham in full-res pixel space
static void fb_draw_line(fb_ctx_t *ctx, int x0, int y0, int x1, int y1, uint8_t value) {
    int dx = abs(x1 - x0);
    int sx = (x0 < x1) ? 1 : -1;
    int dy = -abs(y1 - y0);
    int sy = (y0 < y1) ? 1 : -1;
    int err = dx + dy;

    int x = x0;
    int y = y0;

    while (1) {
        fb_draw_thick_point(ctx, x, y, value);
        if (x == x1 && y == y1) break;
        int e2 = 2 * err;
        if (e2 >= dy) { err += dy; x += sx; }
        if (e2 <= dx) { err += dx; y += sy; }
    }
}

// ============================================================================
// PBM load
// ============================================================================

// Load a full-screen P1 PBM into:
// - g_bitmap (1=black, 0=white)
// - framebuffer (0x00=black, 0xFF=white)
static int load_pbm_into_fb(fb_ctx_t *ctx, const char *path) {
    if (!ctx || !ctx->fbp) {
        fprintf(stderr, "load_pbm_into_fb: framebuffer not initialized\n");
        return -1;
    }

    FILE *f = fopen(path, "r");
    if (!f) {
        perror("fopen load_pbm_into_fb");
        return -1;
    }

    // Read magic "P1"
    char magic[3] = {0};
    if (!fgets(magic, sizeof(magic), f)) {
        fprintf(stderr, "load_pbm_into_fb: failed to read magic\n");
        fclose(f);
        return -1;
    }
    if (magic[0] != 'P' || magic[1] != '1') {
        fprintf(stderr, "load_pbm_into_fb: not a P1 PBM file\n");
        fclose(f);
        return -1;
    }

    // Read width/height (no comments in our own PBMs)
    int w = 0, h = 0;
    if (fscanf(f, "%d %d", &w, &h) != 2) {
        fprintf(stderr, "load_pbm_into_fb: failed to read width/height\n");
        fclose(f);
        return -1;
    }

    if (w != g_fb_width || h != g_fb_height) {
        fprintf(stderr,
                "load_pbm_into_fb: size mismatch (pbm=%dx%d, fb=%dx%d)\n",
                w, h, g_fb_width, g_fb_height);
        fclose(f);
        return -1;
    }

    // Clear current content (framebuffer + g_bitmap)
    fb_clear(ctx, 0xFF);  // white background

    // Read each pixel (0/1) and map: 1 -> black (0x00), 0 -> white (0xFF)
    for (int y = 0; y < h; y++) {
        for (int x = 0; x < w; x++) {
            int bit = 0;
            if (fscanf(f, "%d", &bit) != 1) {
                fprintf(stderr,
                        "load_pbm_into_fb: unexpected EOF or parse error\n");
                fclose(f);
                return -1;
            }
            uint8_t v = bit ? 0x00 : 0xFF;
            fb_set_pixel(ctx, x, y, v);
        }
    }

    fclose(f);

    // Ensure data is pushed out to the device
    msync(ctx->fbp, ctx->screensize, MS_SYNC);

    return 0;
}

// ============================================================================
// PNG export using LodePNG
// ============================================================================

// Convert g_bitmap (1-bit as bytes) to RGBA and write PNG.
static int save_page_png(const char *png_path) {
    if (!g_bitmap || g_fb_width <= 0 || g_fb_height <= 0) return -1;

    size_t w = (size_t)g_fb_width;
    size_t h = (size_t)g_fb_height;
    size_t num_pixels = w * h;
    size_t buf_size = num_pixels * 4;

    unsigned char *image = (unsigned char *)malloc(buf_size);
    if (!image) {
        perror("malloc PNG buffer");
        return -1;
    }

    for (size_t i = 0; i < num_pixels; i++) {
        uint8_t bit = g_bitmap[i];          // 1=black, 0=white
        uint8_t c = bit ? 0x00 : 0xFF;      // black or white
        size_t idx = i * 4;
        image[idx + 0] = c;   // R
        image[idx + 1] = c;   // G
        image[idx + 2] = c;   // B
        image[idx + 3] = 0xFF; // A
    }

    unsigned error = lodepng_encode32_file(png_path, image, (unsigned)w, (unsigned)h);
    free(image);

    if (error) {
        fprintf(stderr, "LodePNG error %u: %s\n", error, lodepng_error_text(error));
        return -1;
    }

    return 0;
}

// ============================================================================
// PBM save
// ============================================================================


// Save current g_bitmap as a P1 PBM in /mnt/us/simple_notes with timestamped name.
// Additionally write a PNG with the same basename via LodePNG.
static void save_page(void) {
    if (!g_bitmap || g_fb_width <= 0 || g_fb_height <= 0) return;

    time_t now = time(NULL);
    struct tm *tm = localtime(&now);

    mkdir(US_SAVE_PATH, 0777);

    char file_ts[50];
    char pbm_path[160];
    char png_path[160];

    // Base name with .pbm
    snprintf(file_ts, sizeof(file_ts),
             "%04d%02d%02d-%02d%02d%02d",
             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
             tm->tm_hour, tm->tm_min, tm->tm_sec);

    //build pbm file path -> only one pbm ist stored because of its size atm so filename latest.fb
    snprintf(pbm_path, sizeof(pbm_path), "%s/bin/latest.fb", US_SAVE_PATH);

    //build png fale using timestamp and global save path
    snprintf(png_path, sizeof(png_path), "%s/note-%s.png", US_SAVE_PATH, file_ts);


    // --- PBM write as before ---
    FILE *f = fopen(pbm_path, "w");
    if (!f) {
        perror("fopen save_page (PBM)");
        return;
    }

    fprintf(f, "P1\n");
    fprintf(f, "%d %d\n", g_fb_width, g_fb_height);
    for (int y = 0; y < g_fb_height; y++) {
        for (int x = 0; x < g_fb_width; x++) {
            size_t idx = (size_t)y * g_fb_width + (size_t)x;
            int v = (idx < (size_t)g_fb_width * g_fb_height && g_bitmap[idx]) ? 1 : 0;
            fputc(v ? '1' : '0', f);
            if (x < g_fb_width - 1) fputc(' ', f);
        }
        fputc('\n', f);
    }
    fclose(f);

    // --- PNG write via LodePNG ---
    int png_ok = save_page_png(png_path);

    char msg[256];
    if (png_ok == 0) {
        snprintf(msg, sizeof(msg),
                 "eips 7 1 \"Saved: note-%s.png\"",
                 file_ts);
    } else {
        snprintf(msg, sizeof(msg),
                 "eips 7 1 \"Failed saving PNG - %s\"",
                 file_ts);
    }
    system(msg);
}

// ============================================================================
// UI / title
// ============================================================================

// Draw a small "X" icon in the topbar (currently unused, kept for reference)
static void draw_topbar_icons(fb_ctx_t *ctx) {
    int margin = 10;
    int size = TOPBAR_H - 5 * margin;
    if (size <= 0) return;

    int x1 = g_fb_width - margin - size;
    int y1 = margin;
    int x2 = g_fb_width - margin;
    int y2 = margin + size;

    fb_draw_line(ctx, x1, y1, x2, y2, 0x00);
    fb_draw_line(ctx, x1, y2, x2, y1, 0x00);
}

// Draw a small PNG icon using eips at absolute pixel coordinates.
static void draw_icon_png(const char *file, int x, int y)
{
    char path[160];

    // Build: /mnt/us/penpad/assets/<file>
    snprintf(path, sizeof(path), "%s/assets/%s", US_HOME_PATH, file);

    char cmd[512];
    // -g : PNG
    // -x, -y : position
    snprintf(cmd, sizeof(cmd),
             "eips -g %s -x %d -y %d",
             path, x, y);

    system(cmd);
}

static void printTitle(void) {
    system("eips -a 40");
    system("eips 0 0 \"   \"");
    system("eips 12 1 \"simplenotes by maru21\"");

    draw_icon_png("exit.png", 1800, 1);
    draw_icon_png("reset.png", 1795, 2410);
    draw_icon_png("save.png", 100, 1);
}

// ============================================================================
// Mapping raw stylus → screen pixels
// ============================================================================

// X: raw left ~15624, right ~0 → reversed axis.
// raw range RAW_X_MIN..RAW_X_MAX mapped to pixel 0..(xres-1).
static int map_raw_to_px(int rawx, const fb_ctx_t *ctx) {
    if (rawx < RAW_X_MIN) rawx = RAW_X_MIN;
    if (rawx > RAW_X_MAX) rawx = RAW_X_MAX;
    int range = RAW_X_MAX - RAW_X_MIN;
    if (range <= 0) return 0;

    // reverse axis: RAW_X_MAX → x=0, RAW_X_MIN → x=max
    int reversed = RAW_X_MAX - rawx;
    int px = reversed * (int)(ctx->vinfo.xres - 1) / (range + 1);
    if (px < 0) px = 0;
    if (px >= (int)ctx->vinfo.xres) px = ctx->vinfo.xres - 1;
    return px;
}

// Y: raw top ~20832, bottom ~0 → inverted.
// raw range RAW_Y_MIN..RAW_Y_MAX mapped to pixel 0..(yres-1).
static int map_raw_to_py(int rawy, const fb_ctx_t *ctx) {
    if (rawy < RAW_Y_MIN) rawy = RAW_Y_MIN;
    if (rawy > RAW_Y_MAX) rawy = RAW_Y_MAX;
    int range = RAW_Y_MAX - RAW_Y_MIN;
    if (range <= 0) return 0;

    int inverted = RAW_Y_MAX - rawy;
    int py = inverted * (int)(ctx->vinfo.yres - 1) / (range + 1);
    if (py < 0) py = 0;
    if (py >= (int)ctx->vinfo.yres) py = ctx->vinfo.yres - 1;
    return py;
}

static int u_map_raw_to_px(int rawx, const fb_ctx_t *ctx) {
    if (rawx < RAW_X_MIN) rawx = RAW_X_MIN;
    if (rawx > RAW_X_MAX) rawx = RAW_X_MAX;
    int range = RAW_X_MAX - RAW_X_MIN;
    if (range <= 0) return 0;

    // direct mapping, no reversed axis
    int px = (rawx - RAW_X_MIN) * (int)(ctx->vinfo.xres - 1) / range;

    if (px < 0) px = 0;
    if (px >= (int)ctx->vinfo.xres) px = ctx->vinfo.xres - 1;
    return px;
}

static int u_map_raw_to_py(int rawy, const fb_ctx_t *ctx) {
    if (rawy < RAW_Y_MIN) rawy = RAW_Y_MIN;
    if (rawy > RAW_Y_MAX) rawy = RAW_Y_MAX;
    int range = RAW_Y_MAX - RAW_Y_MIN;
    if (range <= 0) return 0;

    // direct mapping, no inversion
    int py = (rawy - RAW_Y_MIN) * (int)(ctx->vinfo.yres - 1) / range;

    if (py < 0) py = 0;
    if (py >= (int)ctx->vinfo.yres) py = ctx->vinfo.yres - 1;
    return py;
}


// ============================================================================
// Double-tap handling
// ============================================================================
//
// Zones:
//   top-left      (py < TOPBAR_H, px <  g_fb_width/2)  → save
//   top-right     (py < TOPBAR_H, px >= g_fb_width/2)  → exit
//   bottom-right  (py > g_fb_height - TOPBAR_H,
//                  px >= g_fb_width/2)                 → reset (no save)
//
// Returns:
//   0 = no action
//   1 = double-tap top-left      (save)
//   2 = double-tap top-right     (exit)
//   3 = double-tap bottom-right  (reset page, no save)

static int handle_tap(int px, int py) {
    tap_zone_t zone = TAP_NONE;

    if (py < TOPBAR_H) {
        zone = (px < g_fb_width / 2) ? TAP_LEFT : TAP_RIGHT;
    } else if (py > g_fb_height - TOPBAR_H && px >= g_fb_width / 2) {
        zone = TAP_BOTTOM_RIGHT;
    } else {
        // outside gesture regions: reset tap tracking
        g_tap_count = 0;
        g_last_tap_zone = TAP_NONE;
        return 0;
    }

    time_t now_t = time(NULL);

    if (zone == g_last_tap_zone &&
        (now_t - g_last_tap_timestamp) <= DOUBLE_TAP_WINDOW_SEC) {
        g_tap_count++;
    } else {
        g_tap_count = 1;
        g_last_tap_zone = zone;
    }
    g_last_tap_timestamp = now_t;

    if (g_tap_count >= 2) {
        g_tap_count = 0;
        g_last_tap_zone = TAP_NONE;
        if (zone == TAP_LEFT)              return 1;
        else if (zone == TAP_RIGHT)        return 2;
        else if (zone == TAP_BOTTOM_RIGHT) return 3;
    }

    return 0;
}

// ============================================================================
// main
// ============================================================================

int main(int argc, char **argv) {
    fb_ctx_t fb;
    if (fb_init(&fb, DEV_PATH_FB) != 0) {
        fprintf(stderr, "fb_init failed\n");
        return 1;
    }

    int stylus_fd = open(DEV_PATH_STYLUS, O_RDONLY);
    if (stylus_fd < 0) {
        perror("open stylus");
        fb_close(&fb);
        return 1;
    }

    // Exclusive grab so the framework cannot see stylus events
    if (ioctl(stylus_fd, EVIOCGRAB, (void *)1) < 0) {
        perror("EVIOCGRAB stylus");
        close(stylus_fd);
        fb_close(&fb);
        return 1;
    }

    int touch_fd = open(DEV_PATH_TOUCH, O_RDONLY);
    if (touch_fd < 0) {
        perror("open touch");
        touch_fd = -1;  // weiterlaufen ohne Touch-Grab
    } else {
        // Exclusive grab so the framework cannot see touch events
        if (ioctl(touch_fd, EVIOCGRAB, (void *)1) < 0) {
            perror("EVIOCGRAB touch");
            // trotzdem weiterlaufen, touch_fd bleibt offen
        }
    }

    // Give the framework time to draw its last stuff, then wipe it away.
    sleep(1);
    fb_clear(&fb, 0xFF);  // all white (also clears g_bitmap)

    system("eips -c");

    // ---- Load PBM if provided as first argument ----
    if (argc > 1) {
        const char *pbm_path = argv[1];
        fprintf(stderr, "Loading PBM: %s\n", pbm_path);

        if (load_pbm_into_fb(&fb, pbm_path) != 0) {
            fprintf(stderr, "Failed to load PBM from %s\n", pbm_path);
        }
    }

    printTitle();
    //draw_topbar_icons(&fb);

    fb_flush();

    struct input_event ev;
    int32_t stylus_raw_x = 0;
    int32_t stylus_raw_y = 0;
    int pen_is_down = 0;
    int last_pen_px = -1;
    int last_pen_py = -1;

    uint64_t last_flush = now_ms();
    int dirty_since_flush = 0;

    while (1) {
        ssize_t r = read(stylus_fd, &ev, sizeof(ev));
        if (r < (ssize_t)sizeof(ev)) {
            if (r < 0 && errno == EINTR) continue;
            perror("read stylus");
            break;
        }

        if (ev.type == EV_ABS) {
            if (ev.code == ABS_X) stylus_raw_x = ev.value;
            else if (ev.code == ABS_Y) stylus_raw_y = ev.value;
        } else if (ev.type == EV_KEY && ev.code == 0x14A) {
            // Pen down / up
            pen_is_down = (ev.value == 1);
            if (!pen_is_down) {
                last_pen_px = last_pen_py = -1;
            }

            // Double-tap detection ONLY on pen-down events
            if (ev.value == 1) {
                int px = map_raw_to_px(stylus_raw_x, &fb);
                int py = map_raw_to_py(stylus_raw_y, &fb);

                int tap_result = handle_tap(px, py);
                if (tap_result == 1) {
                    // top-left: save (PBM + PNG)
                    fb_flush();
                    save_page();
                    sleep(SAVE_FEEDBACK_SLEEP_SEC);
                    fb_clear(&fb, 0xFF);
                    system("eips -c");
                    printTitle();
                    //draw_topbar_icons(&fb);
                    fb_flush();

                    // reset stroke state and skip drawing for this event
                    pen_is_down = 0;
                    last_pen_px = last_pen_py = -1;
                    continue;
                } else if (tap_result == 2) {
                    // top-right: EXIT
                    fb_flush();
                    //save_page();
                    fb_clear(&fb, 0xFF);
                    system("eips 1 1 \"bye bye\"");
                    break;  // aus while(1)
                } else if (tap_result == 3) {
                    // bottom-right: RESET (no save)
                    fb_flush();
                    fb_clear(&fb, 0xFF);
                    system("eips -c");
                    printTitle();
                    //draw_topbar_icons(&fb);
                    fb_flush();

                    // reset stroke state and skip drawing for this event
                    pen_is_down = 0;
                    last_pen_px = last_pen_py = -1;
                    continue;
                }
            }
        }

        // Drawing while pen is down
        if (pen_is_down) {
            int px = map_raw_to_px(stylus_raw_x, &fb);
            int py = map_raw_to_py(stylus_raw_y, &fb);

            // Do not draw in top bar
            if (py >= TOPBAR_H) {
                if (last_pen_px >= 0 && last_pen_py >= 0) {
                    fb_draw_line(&fb, last_pen_px, last_pen_py, px, py, 0x00);
                } else {
                    fb_draw_thick_point(&fb, px, py, 0x00);
                }
                last_pen_px = px;
                last_pen_py = py;
                dirty_since_flush = 1;
            } else {
                // If pen moves into top bar, break the stroke
                last_pen_px = last_pen_py = -1;
            }
        }

        uint64_t now_m = now_ms();
        if (dirty_since_flush && (now_m - last_flush >= REFRESH_INTERVAL_MS)) {
            fb_flush();
            last_flush = now_m;
            dirty_since_flush = 0;
        }
    }

    // On normal loop break: release stylus/touch grab and clean up
    ioctl(stylus_fd, EVIOCGRAB, (void *)0);
    close(stylus_fd);

    if (touch_fd >= 0) {
        ioctl(touch_fd, EVIOCGRAB, (void *)0);
        close(touch_fd);
    }

    fb_close(&fb);
    return 0;
}