#include <M5Unified.h>
#include <cstdio>
#include <esp_sleep.h>
#include <esp_wifi.h>
#include <esp_netif.h>
#include <string.h>
#include <SimpleFTPServer.h>
#include "wifi_scanner.h"
#include "unifont24_vlw.h"

// ============================================================
//  Face state enum — drives eye/mouth expressions
// ============================================================
enum FaceState {
  FACE_IDLE,       // (ʘ_ʘ)  default, waiting
  FACE_SCANNING,   // (⌐■_■) active WiFi/BLE sniff
  FACE_HANDSHAKE,  // (★_★)  valuable PCAP captured
  FACE_ERROR,      // (>_<)  SD failure or system error
  FACE_HTTP,       // (O_O)  hosting FTP server + management AP
  FACE_SLEEP       // (x_x)  deep-sleep transition
};

// ============================================================
//  System state
// ============================================================
bool      scanActive    = false;
bool      bleActive     = false;
bool      gpsActive     = false;
bool      autowActive   = false;
bool      ftpActive     = false;
bool      int5Active    = false;
static const uint8_t INT_INTERVALS[] = {5, 10, 20};
uint8_t   intIntervalIdx = 0;  // index into INT_INTERVALS

FaceState currentFace     = FACE_IDLE;
char      faceLabel[32]   = "IDLE";
char      faceCaption[32] = "";
char      discoveredStr[64] = "";
uint8_t   battPct         = 0;

unsigned long runStart  = 0;
bool          runActive = false;

// ============================================================
//  Management AP + FTP server
// ============================================================
static const char FTP_AP_SSID[] = "Shikigami";
static const char FTP_AP_PASS[] = "wardriving";   // WPA2 min-8
static const char FTP_USER[]    = "admin";
static const char FTP_PASS[]    = "shiki1337";
static const char FTP_AP_IP[]   = "192.168.4.1";

static FtpServer ftpSrv;

// ============================================================
//  Auto-wake cycle state — persisted across deep sleep via RTC RAM
// ============================================================

// Maximum BSSIDs tracked across sleep/wake cycles (~2400 bytes RTC RAM)
static const int AUTOWAKE_MAX_SEEN = 400;

RTC_DATA_ATTR static bool    rAutoWakeActive       = false;
RTC_DATA_ATTR static uint8_t rAutoWakeIntervalMins = 5;
RTC_DATA_ATTR static int     rSeenCount            = 0;
RTC_DATA_ATTR static uint8_t rSeenBSSIDs[AUTOWAKE_MAX_SEEN][6];

// Run timer — elapsed ms at time of last sleep, so it survives deep-sleep cycles.
RTC_DATA_ATTR static uint32_t rRunElapsedMs = 0;
RTC_DATA_ATTR static bool     rRunWasActive = false;

static bool bssidIsSeen(const uint8_t* b) {
  for (int i = 0; i < rSeenCount; i++) {
    if (memcmp(rSeenBSSIDs[i], b, 6) == 0) return true;
  }
  return false;
}

static void bssidMarkSeen(const uint8_t* b) {
  if (rSeenCount < AUTOWAKE_MAX_SEEN) {
    memcpy(rSeenBSSIDs[rSeenCount++], b, 6);
  }
}

// ============================================================
//  Layout constants — 540 × 960 display
// ============================================================

// Header bar (full width)
static const int HDR_X        = 0;
static const int HDR_Y        = 5;
static const int HDR_W        = 540;
static const int HDR_H        = 45;

// Version string
static const int VER_X        = 10;
static const int VER_Y        = 65;

// Side indicators (GPS left / ACCEL right)
static const int IND_Y        = 98;

// Face region bounding box — partial-refresh target
static const int FACE_BOX_X   = 70;
static const int FACE_BOX_Y   = 115;
static const int FACE_BOX_W   = 400;
static const int FACE_BOX_H   = 285;
static const int FACE_CX      = 270;   // horizontal centre of display
static const int FACE_CY      = 245;   // vertical centre of face bbox

// Labels above / below face
static const int FLAVOR_Y     = 123;
static const int FLAVOR2_Y    = 408;

// POWER OFF bar (full width)
static const int PWROFF_X     = 0;
static const int PWROFF_Y     = 425;
static const int PWROFF_W     = 540;
static const int PWROFF_H     = 50;

// Discovered device text
static const int DISC_Y       = 502;

// Button grid
static const int BTN_W        = 270;
static const int BTN_H        = 80;
static const int COL1_X       = 0;
static const int COL2_X       = 270;
static const int ROW1_Y       = 640;
static const int ROW2_Y       = 720;
static const int ROW3_Y       = 800;
static const int ROW4_Y       = 880;
static const int FULLBTN_W    = 540;

// ============================================================
//  Forward declarations
// ============================================================
void drawFullUI();
void updateHeader();
void drawVersionLine();
void drawIndicators();
void updateFaceRegion();
void drawFaceGraphic();
void drawPowerOffBar();
void drawDiscoveredText();
void updateButtonGrid();
void drawButton(int x, int y, int w, int h, const char* label, bool isActive);
void handleTouch(int x, int y);

// ============================================================
//  drawButton — inverted when active, outlined when inactive
// ============================================================
void drawButton(int x, int y, int w, int h, const char* label, bool isActive) {
  if (isActive) {
    M5.Display.fillRect(x, y, w, h, TFT_BLACK);
    M5.Display.setTextColor(TFT_WHITE, TFT_BLACK);
  } else {
    M5.Display.fillRect(x, y, w, h, TFT_WHITE);
    // 3-pixel thick border for inactive buttons
    M5.Display.drawRect(x,   y,   w,     h,     TFT_BLACK);
    M5.Display.drawRect(x+1, y+1, w - 2, h - 2, TFT_BLACK);
    M5.Display.drawRect(x+2, y+2, w - 4, h - 4, TFT_BLACK);
    M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  }
  M5.Display.setTextDatum(middle_center);
  M5.Display.setTextSize(2);
  M5.Display.drawString(label, x + w / 2, y + h / 2);
}

// ============================================================
//  Header bar — STAT / RUN timer / battery
// ============================================================
void updateHeader() {
  M5.Display.fillRect(HDR_X, HDR_Y, HDR_W, HDR_H, TFT_WHITE);

  // Battery — right-aligned, nub on LEFT facing the line
  const int BW = 48, BH = 20, R = 3;
  const int NUB_W = 5, NUB_H = 10;
  const int BX = HDR_W - 6 - BW;
  const int LINE_Y = HDR_Y + HDR_H - BH / 2 - 2;   // leave 2px gap below battery
  const int BY = LINE_Y - BH / 2;                   // battery centered on the line
  const int NUB_X = BX - NUB_W;
  const int NUB_Y = LINE_Y - NUB_H / 2;  // centered on the line

  // Nub (solid, left of body)
  M5.Display.fillRect(NUB_X, NUB_Y, NUB_W, NUB_H, TFT_BLACK);

  // Battery body
  M5.Display.fillRoundRect(BX, BY, BW, BH, R, TFT_WHITE);
  M5.Display.drawRoundRect(BX,     BY,     BW,     BH,     R, TFT_BLACK);
  M5.Display.drawRoundRect(BX + 1, BY + 1, BW - 2, BH - 2, R, TFT_BLACK);

  // Fill bar
  const int fillW = (BW - 6) * battPct / 100;
  if (fillW > 0)
    M5.Display.fillRoundRect(BX + 3, BY + 3, fillW, BH - 6, 1, TFT_BLACK);

  // Percent label
  char batBuf[8];
  snprintf(batBuf, sizeof(batBuf), "%d%%", battPct);
  M5.Display.setTextDatum(middle_center);
  M5.Display.setTextSize(1);
  M5.Display.setTextColor(fillW > 0 && battPct > 50 ? TFT_WHITE : TFT_BLACK, TFT_WHITE);
  M5.Display.drawString(batBuf, BX + BW / 2, BY + BH / 2);

  // Bottom line — left edge to 4px before nub
  M5.Display.drawFastHLine(HDR_X, LINE_Y,     NUB_X - 4, TFT_BLACK);
  M5.Display.drawFastHLine(HDR_X, LINE_Y - 1, NUB_X - 4, TFT_BLACK);
  M5.Display.drawFastHLine(HDR_X, LINE_Y - 2, NUB_X - 4, TFT_BLACK);

  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  M5.Display.setTextSize(2);

  // Left — status label reflects current operating state
  const char* statStr;
  if      (currentFace == FACE_SLEEP)    statStr = "STAT:  SLEEP";
  else if (ftpActive)                    statStr = "STAT:  FTP";
  else if (scanActive)                   statStr = "STAT:  SCAN";
  else                                   statStr = "STAT:  WAIT";
  M5.Display.setTextDatum(middle_left);
  M5.Display.drawString(statStr, HDR_X + 8, HDR_Y + HDR_H / 2);

  // Right-aligned — run timer
  char timeBuf[20];
  if (runActive) {
    unsigned long e = (millis() - runStart) / 1000;
    snprintf(timeBuf, sizeof(timeBuf), "RUN:  %02lu:%02lu:%02lu",
             e / 3600, (e % 3600) / 60, e % 60);
  } else {
    snprintf(timeBuf, sizeof(timeBuf), "RUN:  00:00:00");
  }
  M5.Display.setTextDatum(middle_right);
  M5.Display.drawString(timeBuf, NUB_X - 8, HDR_Y + HDR_H / 2);
}

// ============================================================
//  Version string
// ============================================================
void drawVersionLine() {
  M5.Display.fillRect(0, VER_Y - 12, 540, 24, TFT_WHITE);
  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  M5.Display.setTextDatum(middle_left);
  M5.Display.setTextSize(1);
  M5.Display.drawString("Shikigami v0.1-{git}", VER_X, VER_Y);
  M5.Display.setTextSize(2);
}

// ============================================================
//  Side indicators — GPS (left) / ACCEL (right)
// ============================================================
void drawIndicators() {
  M5.Display.fillRect(0, IND_Y - 12, 540, 24, TFT_WHITE);
  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  M5.Display.setTextSize(1);
  M5.Display.setTextDatum(middle_left);
  M5.Display.drawString("GPS", 10, IND_Y);
  M5.Display.setTextDatum(middle_right);
  M5.Display.drawString("ACCEL", 530, IND_Y);
  M5.Display.setTextSize(2);
}

// ============================================================
//  Face graphic — drawn into FACE_BOX bounding box
//  Eye geometry shared across all states; only eye/mouth style changes.
// ============================================================
void drawFaceGraphic() {
  static const char* const FACE_STR[] = {
    "(\xCA\x98_\xCA\x98)",    // FACE_IDLE      (ʘ_ʘ)
    "(\xE2\x8C\x90\xE2\x96\xA0_\xE2\x96\xA0)",  // FACE_SCANNING  (⌐■_■)
    "(\xE2\x98\x85_\xE2\x98\x85)",  // FACE_HANDSHAKE (★_★)
    "(>_<)",                  // FACE_ERROR
    "(O_O)",                  // FACE_HTTP
    "(x_x)",                  // FACE_SLEEP
  };
  M5.Display.loadFont(unifont24_vlw);
  M5.Display.setTextSize(4);
  M5.Display.setTextDatum(middle_center);
  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  M5.Display.drawString(FACE_STR[currentFace], FACE_CX, FACE_CY);
  M5.Display.unloadFont();
}

// Clears the face bounding box and redraws labels + graphic.
// When FTP is active, replaces the face with connection info instead.
void updateFaceRegion() {
  M5.Display.fillRect(FACE_BOX_X, FACE_BOX_Y, FACE_BOX_W, FACE_BOX_H, TFT_WHITE);
  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  M5.Display.setTextDatum(middle_center);
  M5.Display.setTextSize(1);
  M5.Display.drawString(faceLabel, FACE_CX, FLAVOR_Y);

  if (ftpActive) {
    // Replace face graphic with FTP/AP connection details
    char line1[48], line2[48], line3[48];
    snprintf(line1, sizeof(line1), "SSID: %s",  FTP_AP_SSID);
    snprintf(line2, sizeof(line2), "ftp://%s",  FTP_AP_IP);
    snprintf(line3, sizeof(line3), "%s / %s",   FTP_USER, FTP_PASS);
    const int infoSpacing = 45;
    const int infoTop     = FACE_CY - infoSpacing;
    M5.Display.setTextSize(2);
    M5.Display.drawString(line1, FACE_CX, infoTop);
    M5.Display.drawString(line2, FACE_CX, infoTop + infoSpacing);
    M5.Display.drawString(line3, FACE_CX, infoTop + infoSpacing * 2);
  } else {
    drawFaceGraphic();
  }

  M5.Display.setTextSize(1);
  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  M5.Display.setTextDatum(middle_center);
  M5.Display.drawString(faceCaption, FACE_CX, FLAVOR2_Y);
  M5.Display.setTextSize(2);
}

// ============================================================
//  POWER OFF bar — full-width inverted
// ============================================================
void drawPowerOffBar() {
  M5.Display.fillRect(PWROFF_X, PWROFF_Y, PWROFF_W, PWROFF_H, TFT_BLACK);
  M5.Display.setTextColor(TFT_WHITE, TFT_BLACK);
  M5.Display.setTextDatum(middle_center);
  M5.Display.setTextSize(2);
  M5.Display.drawString("POWER OFF", PWROFF_X + PWROFF_W / 2, PWROFF_Y + PWROFF_H / 2);
}

// ============================================================
//  Discovered device / status text
// ============================================================
void drawDiscoveredText() {
  M5.Display.fillRect(0, DISC_Y - 20, 540, 40, TFT_WHITE);
  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  M5.Display.setTextDatum(middle_center);
  M5.Display.setTextSize(1);
  M5.Display.drawString(discoveredStr, 270, DISC_Y);
  M5.Display.setTextSize(2);
}

// ============================================================
//  Button grid — 2×2 split + 2 full-width rows
// ============================================================
void updateButtonGrid() {
  drawButton(COL1_X, ROW1_Y, BTN_W,     BTN_H, "SCAN",  scanActive);
  drawButton(COL2_X, ROW1_Y, BTN_W,     BTN_H, "BLE",   bleActive);
  drawButton(COL1_X, ROW2_Y, BTN_W,     BTN_H, "GPS",   gpsActive);
  drawButton(COL2_X, ROW2_Y, BTN_W,     BTN_H, "AUTOW", autowActive);
  drawButton(COL1_X, ROW3_Y, FULLBTN_W, BTN_H, "FTP",   ftpActive);
  char intLabel[16];
  if (int5Active) {
    snprintf(intLabel, sizeof(intLabel), "INT %d", INT_INTERVALS[intIntervalIdx]);
  } else {
    snprintf(intLabel, sizeof(intLabel), "INT 5");
  }
  drawButton(COL1_X, ROW4_Y, FULLBTN_W, BTN_H, intLabel, int5Active);
}

// ============================================================
//  Full-screen draw — used on boot and scheduled full refresh
// ============================================================
void drawFullUI() {
  M5.Display.fillScreen(TFT_WHITE);
  updateHeader();
  drawVersionLine();
  drawIndicators();
  updateFaceRegion();
  if (currentFace == FACE_SLEEP) {
    drawPowerOffBar();
  } else {
    M5.Display.fillRect(PWROFF_X, PWROFF_Y, PWROFF_W, PWROFF_H, TFT_WHITE);
  }
  drawDiscoveredText();
  updateButtonGrid();
}

// ============================================================
//  Deep-sleep entry — draw sleep UI, flush, start timer, sleep
// ============================================================
static void enterDeepSleep(uint8_t minutes) {
  wifiScanner_stop();

  // Snapshot run-timer elapsed before millis() disappears in deep sleep
  rRunWasActive  = runActive;
  rRunElapsedMs  = runActive ? static_cast<uint32_t>(millis() - runStart) : rRunElapsedMs;

  // Draw sleep state — switch to quality mode so white-on-black text renders
  // correctly (epd_fast can't resolve the non-monotone transition in one pass)
  currentFace = FACE_SLEEP;
  strncpy(faceLabel,   "SLEEPING",               sizeof(faceLabel)   - 1);
  snprintf(faceCaption, sizeof(faceCaption), "Wake in %d min", minutes);

  M5.Display.setEpdMode(epd_mode_t::epd_quality);
  M5.Display.fillScreen(TFT_WHITE);
  updateHeader();
  updateFaceRegion();
  drawPowerOffBar();
  M5.Display.display();   // blocking full refresh before power-down

  esp_sleep_enable_timer_wakeup((uint64_t)minutes * 60ULL * 1000000ULL);
  esp_deep_sleep_start();
  // never returns
}

// ============================================================
//  Auto-wake scan cycle — runs in setup() on timer wakeup,
//  never returns (re-enters deep sleep when done).
// ============================================================
static const unsigned long AUTOWAKE_SCAN_MS = 30000UL;

static void autoWakeScanCycle() {
  int rawBatt = M5.Power.getBatteryLevel();
  battPct = (uint8_t)(rawBatt > 0 ? rawBatt : 0);

  wifiScanner_init();
  wifiScanner_startTask();
  wifiScanner_start();

  // Show minimal scanning UI — e-ink retains POWER OFF bar from sleep screen,
  // only partial-refresh the header and face region
  currentFace = FACE_SCANNING;
  strncpy(faceLabel,   "AUTO-SCAN",   sizeof(faceLabel)   - 1);
  strncpy(faceCaption, "Scanning...", sizeof(faceCaption) - 1);
  updateHeader();
  updateFaceRegion();
  M5.Display.display();

  // Scan for AUTOWAKE_SCAN_MS, draining packet queue to avoid overflow
  const unsigned long scanEnd = millis() + AUTOWAKE_SCAN_MS;
  while (millis() < scanEnd) {
    WifiPacket pkt;
    while (xQueueReceive(wifiPacketQueue, &pkt, 0) == pdTRUE) {
      (void)pkt;  // TODO: pass to pcapWriter_enqueue()
    }
    vTaskDelay(100 / portTICK_PERIOD_MS);
  }

  wifiScanner_stop();

  // Count new APs not seen in previous cycles
  const WifiAP* apList  = nullptr;
  int           apCount = 0;
  wifiScanner_getAPList(&apList, &apCount);

  int newCount = 0;
  if (apList) {
    for (int i = 0; i < apCount; i++) {
      if (!bssidIsSeen(apList[i].bssid)) {
        bssidMarkSeen(apList[i].bssid);
        newCount++;
      }
    }
  }

  // Show results briefly before sleeping again
  if (newCount > 0) {
    currentFace = FACE_HANDSHAKE;
    snprintf(faceCaption,  sizeof(faceCaption),  "+%d new AP%s", newCount, newCount == 1 ? "" : "s");
  } else {
    currentFace = FACE_IDLE;
    strncpy(faceCaption, "No new APs", sizeof(faceCaption) - 1);
  }
  snprintf(faceLabel, sizeof(faceLabel), "Seen: %d total", rSeenCount);
  // Partial refresh only — POWER OFF bar already on screen from sleep render
  updateFaceRegion();
  M5.Display.display();

  vTaskDelay(2500 / portTICK_PERIOD_MS);

  enterDeepSleep(rAutoWakeIntervalMins);
  // never returns
}

// ============================================================
//  Management AP helpers
// ============================================================

// AP netif handle — created once, reused on subsequent enable/disable cycles.
static esp_netif_t* s_apNetif = nullptr;

// Start softAP using raw IDF so we stay consistent with the scanner's
// esp_wifi_* setup and avoid Arduino WiFi library reinitialising the stack.
static void startManagementAP() {
  if (!s_apNetif) {
    s_apNetif = esp_netif_create_default_wifi_ap();
  }

  // Switch to AP-only mode (scanner is stopped before this is called)
  esp_wifi_set_mode(WIFI_MODE_AP);

  wifi_config_t ap_cfg = {};
  memcpy(ap_cfg.ap.ssid,     FTP_AP_SSID, strlen(FTP_AP_SSID));
  memcpy(ap_cfg.ap.password, FTP_AP_PASS, strlen(FTP_AP_PASS));
  ap_cfg.ap.ssid_len       = static_cast<uint8_t>(strlen(FTP_AP_SSID));
  ap_cfg.ap.channel        = 6;
  ap_cfg.ap.max_connection = 2;
  ap_cfg.ap.authmode       = WIFI_AUTH_WPA2_PSK;
  esp_wifi_set_config(WIFI_IF_AP, &ap_cfg);

  // ftpSrv.begin(FTP_USER, FTP_PASS);  // TODO: enable once SD card is mounted
}

static void stopManagementAP() {
  // Return to STA mode so the scanner can re-enable promiscuous
  esp_wifi_set_mode(WIFI_MODE_STA);
}

// ============================================================
//  Run-timer helpers
// ============================================================

// Start the run timer the first time any capture feature is enabled;
// stop it when all capture features are disabled.
static void updateRunTimer() {
  bool anyCapture = scanActive || bleActive;
  if (anyCapture && !runActive) {
    runActive = true;
    runStart  = millis();
  } else if (!anyCapture) {
    runActive = false;
  }
}

// ============================================================
//  Touch handling — each button does its own partial redraw
// ============================================================
void handleTouch(int tx, int ty) {
  // Row 1 — SCAN / BLE
  if (ty >= ROW1_Y && ty < ROW1_Y + BTN_H) {
    if (tx >= COL1_X && tx < COL1_X + BTN_W) {
      scanActive = !scanActive;
      if (scanActive) {
        wifiScanner_start();
        currentFace = FACE_SCANNING;
        strncpy(faceLabel, "SCANNING", sizeof(faceLabel) - 1);
        snprintf(faceCaption, sizeof(faceCaption), "APs: %d", rSeenCount);
        strncpy(discoveredStr, "Listening...", sizeof(discoveredStr) - 1);
      } else {
        wifiScanner_stop();
        currentFace = FACE_IDLE;
        strncpy(faceLabel, "IDLE", sizeof(faceLabel) - 1);
        faceCaption[0]    = '\0';
        discoveredStr[0]  = '\0';
      }
      updateRunTimer();
      drawButton(COL1_X, ROW1_Y, BTN_W, BTN_H, "SCAN", scanActive);
      updateHeader();
      updateFaceRegion();
      drawDiscoveredText();
    } else if (tx >= COL2_X && tx < COL2_X + BTN_W) {
      bleActive = !bleActive;
      updateRunTimer();
      drawButton(COL2_X, ROW1_Y, BTN_W, BTN_H, "BLE", bleActive);
      updateHeader();
    }
  }
  // Row 2 — GPS / AUTOW
  else if (ty >= ROW2_Y && ty < ROW2_Y + BTN_H) {
    if (tx >= COL1_X && tx < COL1_X + BTN_W) {
      gpsActive = !gpsActive;
      drawButton(COL1_X, ROW2_Y, BTN_W, BTN_H, "GPS", gpsActive);
    } else if (tx >= COL2_X && tx < COL2_X + BTN_W) {
      autowActive = !autowActive;
      drawButton(COL2_X, ROW2_Y, BTN_W, BTN_H, "AUTOW", autowActive);
    }
  }
  // Row 3 — FTP management AP (full width)
  // Disables scanner while active; scanner is re-enabled on toggle-off.
  else if (ty >= ROW3_Y && ty < ROW3_Y + BTN_H) {
    if (tx >= COL1_X && tx < COL1_X + FULLBTN_W) {
      ftpActive = !ftpActive;
      if (ftpActive) {
        // Stop scanning before switching WiFi mode
        if (scanActive) {
          wifiScanner_stop();
          scanActive = false;
          updateRunTimer();
          drawButton(COL1_X, ROW1_Y, BTN_W, BTN_H, "SCAN", false);
        }
        startManagementAP();
        currentFace = FACE_HTTP;
        strncpy(faceLabel,   "FTP SERVER", sizeof(faceLabel)   - 1);
        strncpy(faceCaption, FTP_AP_SSID,  sizeof(faceCaption) - 1);
      } else {
        stopManagementAP();
        currentFace = FACE_IDLE;
        strncpy(faceLabel,   "IDLE", sizeof(faceLabel)   - 1);
        faceCaption[0] = '\0';
      }
      drawButton(COL1_X, ROW3_Y, FULLBTN_W, BTN_H, "FTP", ftpActive);
      updateFaceRegion();
    }
  }
  // Row 4 — INT interval: first tap enables auto-wake and sleeps immediately.
  //          While active, subsequent taps cycle the interval and re-sleep.
  //          Final cycle (wraps back to 0) turns auto-wake off.
  else if (ty >= ROW4_Y && ty < ROW4_Y + BTN_H) {
    if (tx >= COL1_X && tx < COL1_X + FULLBTN_W) {
      if (!int5Active) {
        // Turn on — start at 5 min and enter sleep cycle
        int5Active     = true;
        intIntervalIdx = 0;
        rAutoWakeActive       = true;
        rAutoWakeIntervalMins = INT_INTERVALS[intIntervalIdx];
        char intLabel[16];
        snprintf(intLabel, sizeof(intLabel), "INT %d", rAutoWakeIntervalMins);
        drawButton(COL1_X, ROW4_Y, FULLBTN_W, BTN_H, intLabel, true);
        vTaskDelay(1200 / portTICK_PERIOD_MS);
        enterDeepSleep(rAutoWakeIntervalMins);  // never returns
      } else {
        // Cycle interval; wrapping to index 0 turns it off
        intIntervalIdx = (intIntervalIdx + 1) % 3;
        if (intIntervalIdx == 0) {
          int5Active    = false;
          rAutoWakeActive = false;
          drawButton(COL1_X, ROW4_Y, FULLBTN_W, BTN_H, "INT 5", false);
        } else {
          rAutoWakeIntervalMins = INT_INTERVALS[intIntervalIdx];
          char intLabel[16];
          snprintf(intLabel, sizeof(intLabel), "INT %d", rAutoWakeIntervalMins);
          drawButton(COL1_X, ROW4_Y, FULLBTN_W, BTN_H, intLabel, true);
          vTaskDelay(1200 / portTICK_PERIOD_MS);
          enterDeepSleep(rAutoWakeIntervalMins);  // never returns
        }
      }
    }
  }
  // POWER OFF bar
  else if (ty >= PWROFF_Y && ty < PWROFF_Y + PWROFF_H) {
    // TODO: initiate graceful power-off sequence (flush SD, draw sleep face)
  }
}

// ============================================================
//  Setup
// ============================================================
void setup() {
  auto cfg = M5.config();
  M5.begin(cfg);

  // Initial battery reading
  int rawBatt = M5.Power.getBatteryLevel();
  battPct = (uint8_t)(rawBatt > 0 ? rawBatt : 0);

  M5.Display.setEpdMode(epd_mode_t::epd_fast);
  M5.Display.setTextDatum(middle_center);
  M5.Display.setTextSize(2);

  // ---- Woke from timer: run auto-scan cycle and go back to sleep ----
  if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_TIMER && rAutoWakeActive) {
    autoWakeScanCycle();  // never returns
  }

  // ---- Normal boot (first power-on or manual reset) ----
  // Default to INT 5 active: the device is a wardriving appliance —
  // auto-wake is on from the start.
  if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_UNDEFINED) {
    rAutoWakeActive       = true;
    rAutoWakeIntervalMins = INT_INTERVALS[0];  // 5 min
    intIntervalIdx        = 0;
  }

  // Restore INT button UI state from RTC vars
  if (rAutoWakeActive) {
    int5Active = true;
    for (uint8_t i = 0; i < 3; i++) {
      if (INT_INTERVALS[i] == rAutoWakeIntervalMins) { intIntervalIdx = i; break; }
    }
  }

  // Restore run timer — offset runStart so elapsed continues from where it paused
  if (rRunWasActive) {
    runActive = true;
    runStart  = millis() - rRunElapsedMs;
  }

  wifiScanner_init();
  wifiScanner_startTask();

  drawFullUI();
}

// ============================================================
//  Loop
// ============================================================
void loop() {
  M5.update();

  // Drain WiFi packet queue on Core 1 — hand off to PCAP writer (future module).
  {
    WifiPacket pkt;
    while (xQueueReceive(wifiPacketQueue, &pkt, 0) == pdTRUE) {
      // TODO: pass pkt to pcapWriter_enqueue()
      (void)pkt;
    }
  }

  // Refresh scanner-driven UI fields every 2 s while scanning is active.
  if (scanActive) {
    static unsigned long lastScanUIUpdate = 0;
    const unsigned long  now             = millis();
    if (now - lastScanUIUpdate >= 2000UL) {
      lastScanUIUpdate = now;

      const WifiAP* apList  = nullptr;
      int           apCount = 0;
      wifiScanner_getAPList(&apList, &apCount);

      // Absorb any new BSSIDs into RTC lifetime tally
      if (apList) {
        for (int i = 0; i < apCount; i++) {
          if (!bssidIsSeen(apList[i].bssid)) {
            bssidMarkSeen(apList[i].bssid);
          }
        }
      }

      // faceCaption — lifetime unique AP count across all sessions
      snprintf(faceCaption, sizeof(faceCaption), "APs: %d", rSeenCount);

      // discoveredStr — most recently seen AP (last entry in the list)
      if (apList && apCount > 0) {
        const WifiAP& newest = apList[apCount - 1];
        const uint8_t* b     = newest.bssid;
        if (newest.ssid[0] != '\0') {
          snprintf(discoveredStr, sizeof(discoveredStr),
                   "%.32s  [%02X:%02X:%02X:%02X:%02X:%02X]",
                   newest.ssid, b[0], b[1], b[2], b[3], b[4], b[5]);
        } else {
          snprintf(discoveredStr, sizeof(discoveredStr),
                   "[%02X:%02X:%02X:%02X:%02X:%02X] (hidden)",
                   b[0], b[1], b[2], b[3], b[4], b[5]);
        }
      }

      updateFaceRegion();
      drawDiscoveredText();
    }
  }

  auto t = M5.Touch.getDetail();
  if (t.wasPressed()) {
    handleTouch(t.x, t.y);
  }

  // Service FTP server on Core 1 when active.
  if (ftpActive) {
    ftpSrv.handleFTP();
  }

  // Header refresh — tick the run timer every second; poll battery every 30s.
  {
    static unsigned long lastHeaderTick = 0;
    static uint8_t       battTickCount  = 0;
    const unsigned long  now            = millis();
    if (now - lastHeaderTick >= 1000UL) {
      lastHeaderTick = now;
      if (++battTickCount >= 30) {
        battTickCount = 0;
        int rawBatt = M5.Power.getBatteryLevel();
        battPct = (uint8_t)(rawBatt > 0 ? rawBatt : 0);
      }
      updateHeader();
    }
  }

  // Auto-sleep watchdog — if INT mode is active and we've been awake for the
  // full interval, go to sleep now (kicks in whether or not the user is scanning).
  if (int5Active && !ftpActive) {
    const unsigned long intervalMs = (unsigned long)rAutoWakeIntervalMins * 60UL * 1000UL;
    if (millis() >= intervalMs) {
      enterDeepSleep(rAutoWakeIntervalMins);  // never returns
    }
  }
}