telegram.cpp

// telegram.cpp 🤖💬 Модуль Telegram бота на базе FastBot2
// 🌱💧 Система капельного полива с 8 каналами датчиков влажности
#include "telegram.h"
#include "objects.h"
#include "users.h"         // 👥 модель пользователей и их хранение
#include "botutil.h"       // 🧰 isNumeric/getValue/IntWith2Zero
#include "bot_transport.h" // 📡 sendReconnectMessage
#include "reports.h"       // 📊 fileToGraf/fileToGrafPeriod/rm
#include "log.h"
#include <EEPROM.h>
#include "valves.h"
#include "version.h"       // 🏷️ FW_VERSION — версия прошивки в стартовом сообщении
#include "faults.h"        // 🩺 аварийный режим при неисправном оборудовании
#include <Update.h>        // 📤 OTA-запись во flash (для распаковки .gz на лету)
#include <esp_task_wdt.h>  // 🐕 сброс watchdog во время долгой распаковки
#include "uzlib.h"         // 🗜️ потоковая распаковка gzip (vendored, zlib-лицензия)

// ============================================================
// 🎬 Коды состояний диалога (FSM). Диапазоны = база + индекс канала (0..Dlg::Last).
// ============================================================
namespace Dlg {
  constexpr int None          = 0;     // нет активного диалога

  constexpr int Restart       = 1;     // подтверждение перезагрузки
  constexpr int WorkNight     = 1001;  // вкл/выкл работу ночью
  constexpr int WorkRain      = 1002;  // вкл/выкл работу под дождём
  constexpr int DeltaHum      = 1003;  // ввод дельты влажности
  constexpr int DeltaCalib    = 1004;  // ввод дельты калибровки
  constexpr int DelFolder     = 1005;  // ввод года для удаления
  constexpr int BoostPump     = 1006;  // ввод порога насоса давления
  constexpr int ClogThreshold = 1007;  // ввод порога контроля фильтра
  constexpr int TgTimeout     = 1008;  // ввод таймаута связи с Telegram
  constexpr int AutoCalNoDly  = 1009;  // вкл/выкл авто-калибровку без задержки

  // Калибровка датчика (база + индекс канала)
  constexpr int CalibStart    = 1100;  // старт
  constexpr int CalibWet      = 1110;  // замер «вода»
  constexpr int CalibDry      = 1120;  // замер «сухо»
  constexpr int CalibFinish   = 1130;  // завершение

  constexpr int Rename        = 1200;  // переименование датчика (база + канал)
  constexpr int ModeSet       = 1300;  // режим клапана (база + канал)
  constexpr int ModeSetAll    = 1399;  // режим всех клапанов
  constexpr int Border        = 1400;  // порог влажности (база + канал)
  constexpr int CalibManual   = 1800;  // ручная калибровка мин,макс (база + канал)

  constexpr int Reset         = 2000;  // сброс настроек

  constexpr int SearchStart   = 3000;  // поиск датчика: старт
  constexpr int SearchWet     = 3010;  // поиск датчика: замер «вода»
  constexpr int SearchDetect  = 3020;  // поиск датчика: определение

  constexpr int ClearFlow     = 4000;  // стереть данные расхода

  constexpr int SendFile      = 5000;  // отправка CSV по дате
  constexpr int GraphDate     = 5100;  // график за дату
  constexpr int GraphPeriod   = 5200;  // график за период

  constexpr int Last = NUM_CHANNELS - 1;  // верхняя граница диапазона: база + Last
}

// ============================================================
// 🔄 Флаг необходимости сохранения конфигурации на SD-карту
// ============================================================
bool needUpdate = false;

// 🔄 Проверить и сбросить флаг необходимости обновления конфигурации
bool telegramNeedUpdate() {
  bool nu = needUpdate;
  needUpdate = false;
  return nu;
}

// 🔧 Идёт ли у кого-нибудь диалог калибровки или поиска датчика.
// В этих режимах датчик держат в воде / на воздухе — показания заведомо
// нерабочие, поэтому авто-расширение границ калибровки должно быть отключено,
// иначе оно «выучит» калибровочные экстремумы как рабочий диапазон.
bool calibrationInProgress() {
  for (uint8_t i = 0; i < userCount; i++) {
    int a = users[i].action;
    // авто-калибровка: старт → вода → сухо → завершение (1100..1137)
    if (a >= Dlg::CalibStart && a <= Dlg::CalibFinish + Dlg::Last) return true;
    // ручная калибровка (1800..1807)
    if (a >= Dlg::CalibManual && a <= Dlg::CalibManual + Dlg::Last) return true;
    // поиск датчика: замер в воде и определение (3000..3020)
    if (a >= Dlg::SearchStart && a <= Dlg::SearchDetect) return true;
  }
  return false;
}

// 🛡️ Индекс канала, разобранный из команды вида "/BordersSet_N" (пользовательский
// текст или callback), может быть любым числом — кнопки в меню всегда шлют 0..7,
// но ничто не мешает зарегистрированному пользователю набрать команду вручную с
// произвольным N. Без проверки такой N уходит в Dlg::Base + ind и приводит к
// выходу за границы myConfig.chanel[]/HumiditySensors (порча Config, крэш).
static bool validChannelIndex(int ind, const String& userID) {
  if (ind < 0 || ind >= NUM_CHANNELS) {
    sendReconnectMessage(F("❌ Неверный номер канала"), userID);
    return false;
  }
  return true;
}

// 🔘 Проверка нажатия reply-кнопки по её ТЕКСТОВОЙ части (без ведущего эмодзи).
// Метка reply-кнопки возвращается Telegram как текст сообщения, но эмодзи с
// вариационным селектором (например ➡️ = U+27A1 + U+FE0F) в round-trip может
// потерять селектор — тогда точное сравнение `text == "➡️ ДАЛЕЕ"` не срабатывает.
// Отбрасываем всё до первого пробела (эмодзи-префикс) и сравниваем остаток —
// это устойчиво и к «съехавшему» эмодзи, и к ловушкам подстроки (ДА ⊂ ДАЛЕЕ).
static bool btnIs(const String& text, const char* word) {
  int sp = text.indexOf(' ');
  String core = (sp >= 0) ? text.substring(sp + 1) : text;
  core.trim();
  return core == word;
}

// 🌱 Подпись канала «N (Название культуры)» — чтобы в диалогах калибровки было
// видно, какой именно датчик настраивается. Индекс уже проверен вызывающим.
static String chanLabel(int ind) {
  return String(ind + 1) + " (" + String(myConfig.chanel[ind].title) + ")";
}

// 📤 Тип присланного файла прошивки
enum class OtaKind : uint8_t { None, Bin, Gz };

// 📤 Распознать файл прошивки по имени.
// Точное сравнение имён неудобно: Windows при повторном скачивании добавляет
// « (2)» ПЕРЕД расширением, и получается «DripIrrigation.ino.bin (2).gz» или
// «DripIrrigation.ino (2).bin». Поэтому смотрим на префикс (чтобы не прошить
// случайный документ) и на расширение (оно и задаёт способ обновления).
// Регистр игнорируем — некоторые клиенты меняют его при пересылке.
static OtaKind otaKindOf(const String& fileName) {
  String n = fileName;
  n.toLowerCase();
  if (!n.startsWith("dripirrigation")) return OtaKind::None;
  if (n.endsWith(".gz")) return OtaKind::Gz;    // сжатый образ — распакуем сами
  if (n.endsWith(".bin")) return OtaKind::Bin;  // обычный образ
  return OtaKind::None;
}

// ============================================================
// 🎹 Показ меню с учётом контекста (callback-кнопка или текст)
// ============================================================
// По нажатию inline-кнопки редактируем существующее сообщение (меню
// «переключается» на месте); в текстовом контексте (ответ на диалог Да/Нет,
// ввод числа, команда, набранная вручную) редактировать нечего — отправляем
// новое сообщение. Раньше все меню делали editText безусловно, из-за чего
// после текстового ответа меню молча не показывалось.
static void showMenu(fb::Update& u, const String& userID, const String& text, fb::InlineKeyboard& menu) {
  if (u.isQuery()) {
    fb::TextEdit t;
    t.mode = fb::Message::Mode::HTML;
    t.text = text;
    t.chatID = u.query().message().chat().id();
    t.messageID = u.query().message().id();
    t.setKeyboard(&menu);
    bot.editText(t);
  } else {
    fb::Message m;
    m.text = text;
    m.chatID = userID;
    m.setModeHTML();
    m.setKeyboard(&menu);
    bot.sendMessage(m);
  }
}

// 🏠 Главное меню (наполнение зависит от роли; используется при старте и на /Start)
static void buildMainMenu(fb::InlineKeyboard& menu, bool admin) {
  if (admin) {
    menu.addButton("🔄 Перезагрузка", "/Restart", fb::KeyStyle::Danger).newRow()
        .addButton("👥 Пользователи", "/Users", fb::KeyStyle::Primary).newRow();
  }
  menu.addButton("⚙️ Управление", "/Control", fb::KeyStyle::Primary).newRow()
      .addButton("📊 Статус", "/status", fb::KeyStyle::Primary).newRow()
      .addButton("📈 Отчёты", "/Reports", fb::KeyStyle::Primary);
  if (admin) {
    menu.newRow().addButton("🔧 Настройка", "/Configure", fb::KeyStyle::Primary);
  }
}

// ============================================================
// 🗜️📤 OTA из сжатого .gz (распаковка gzip на лету во flash)
// ============================================================
// FastBot2 на ESP32 пишет файл во flash как есть, без распаковки — поэтому .gz
// сам по себе прошить нельзя. Здесь мы скачиваем .gz, потоково распаковываем
// (uzlib) и пишем в Update. Скачивание тяжёлое и делает вложенный HTTP-запрос,
// поэтому его НЕЛЬЗЯ запускать прямо в колбэке newMsg (он вызывается из
// bot.tick()) — колбэк лишь запоминает file_id, а работу делает telegramGzOtaTick()
// из loop(), как и штатный OTA библиотеки откладывается на следующий tick.
static bool   g_gzOtaPending = false;  // запланирована распаковка+прошивка .gz
static String g_gzOtaId;               // file_id принятого архива
static String g_gzOtaUser;             // кому слать уведомления

#define GZ_TMP_PATH "/update.gz"  // куда кладём архив на время обновления
#define GZ_OTA_ATTEMPTS 3         // попыток скачать архив (сеть/память могут подвести)

// 🔌 Источник сжатых данных для uzlib — читаем с SD-карты.
//    Распаковка идёт НЕ из сети, а из файла: сетевой поток отдаёт байты рывками,
//    и распаковщик ломается на паузах канала. Сначала архив целиком скачивается
//    на карту штатным буферизованным writeTo() библиотеки, и только потом
//    распаковывается — чтение с SD стабильно и не зависит от связи.
static File    g_gzFile;
static uint8_t g_gzInBuf[512];

// uzlib в pull-модели дёргает этот колбэк за следующей порцией входа.
// Возвращает первый байт и отдаёт остаток буфера через source/source_limit.
static int gzReadCb(struct uzlib_uncomp* d) {
  int n = g_gzFile.read(g_gzInBuf, sizeof(g_gzInBuf));
  if (n <= 0) return -1;  // конец файла
  d->source = g_gzInBuf + 1;
  d->source_limit = g_gzInBuf + n;
  return g_gzInBuf[0];
}

// 📥 Этап 1: скачать архив с серверов Telegram на SD. Возвращает размер (0 — сбой).
// Скачивание — самое хрупкое место: на TLS-хендшейк нужен крупный непрерывный
// кусок памяти, а после долгой работы куча фрагментирована, и попытка может
// сорваться (у библиотеки это видно как «OTA Fetch Error»). Поэтому пробуем
// несколько раз с паузой — за это время память обычно освобождается.
static size_t gzOtaDownload() {
  for (uint8_t attempt = 1; attempt <= GZ_OTA_ATTEMPTS; attempt++) {
    fb::Fetcher fetch = bot.downloadFile(g_gzOtaId.c_str());
    if (!fetch) {
      LOG_W("OTA .gz: попытка %d — сервер не отдал файл (свободно %u Б)",
            attempt, (unsigned)ESP.getFreeHeap());
      delay(2000);
      esp_task_wdt_reset();
      continue;
    }
    fetch.setTimeout(20000);          // терпимее к паузам мобильного канала
    fetch.setBlockSize(1024);         // блок чтения крупнее дефолтных 128 Б

    SD.remove(GZ_TMP_PATH);
    File f = SD.open(GZ_TMP_PATH, FILE_WRITE);
    if (!f) { LOG_E("OTA .gz: не создать %s на SD", GZ_TMP_PATH); return 0; }

    size_t written = fetch.writeTo(f);  // штатный путь библиотеки с ожиданием данных
    f.close();
    esp_task_wdt_reset();
    LOG_W("OTA .gz: попытка %d — скачано %u байт", attempt, (unsigned)written);
    if (written) return written;
    delay(2000);                        // связь моргнула — пробуем ещё раз
  }
  return 0;
}

// 🗜️ Этап 2: распаковать архив с SD прямо во flash. true — образ принят.
// Безопасно: Update пишет в НЕАКТИВНЫЙ раздел и переключает загрузку только
// при валидном образе — сбой распаковки даёт отказ OTA, а не «кирпич».
static bool gzOtaFlash(String& diag) {
  g_gzFile = SD.open(GZ_TMP_PATH, FILE_READ);
  if (!g_gzFile) { diag = F("не открыть архив на SD"); return false; }

  uint8_t* dict = (uint8_t*)malloc(32768);  // окно LZ (полный deflate)
  if (!dict) { g_gzFile.close(); diag = F("нет памяти под словарь"); return false; }
  uint8_t out[2048];

  struct uzlib_uncomp d;
  memset(&d, 0, sizeof(d));
  uzlib_uncompress_init(&d, dict, 32768);
  d.source = NULL;
  d.source_limit = NULL;
  d.source_read_cb = gzReadCb;

  bool ok = false;
  int res = -1;
  size_t total = 0;
  int hdr = uzlib_gzip_parse_header(&d);

  if (hdr != TINF_OK) {
    diag = String(F("плохой gzip-заголовок (")) + hdr + ")";
  } else if (!Update.begin(UPDATE_SIZE_UNKNOWN, U_FLASH)) {
    diag = String(F("Update.begin: ")) + Update.errorString();
  } else {
    do {
      d.dest = d.dest_start = out;
      d.dest_limit = out + sizeof(out);
      res = uzlib_uncompress_chksum(&d);       // распаковка + сверка CRC32 в конце
      if (res != TINF_OK && res != TINF_DONE) break;
      size_t got = d.dest - out;
      if (got) {
        if (Update.write(out, got) != got) { diag = String(F("Update.write: ")) + Update.errorString(); res = -100; break; }
        total += got;
      }
      esp_task_wdt_reset();                     // 🐕 не даём watchdog сработать
      yield();
    } while (res == TINF_OK);

    if (res == TINF_DONE) {
      ok = Update.end(true);
      if (!ok) diag = String(F("Update.end: ")) + Update.errorString();
    } else if (!diag.length()) {
      // -3 данные, -4 CRC не сошлась, -5 словарь
      diag = String(F("распаковка прервана, код ")) + res;
    }
    if (!ok) Update.abort();
  }

  diag += String(F(", распаковано ")) + total + F(" Б");
  LOG_W("OTA .gz: res=%d, распаковано %u, итог=%s", res, (unsigned)total, ok ? "OK" : "FAIL");
  g_gzFile.close();
  free(dict);
  return ok;
}

// ⏱️ Тик обработки отложенного .gz-OTA — вызывать в loop() (вне колбэка tick).
void telegramGzOtaTick() {
  if (!g_gzOtaPending) return;
  g_gzOtaPending = false;

  sendReconnectMessage(F("📥 Скачиваю архив на SD-карту..."), g_gzOtaUser);
  size_t dl = gzOtaDownload();
  if (!dl) {
    SD.remove(GZ_TMP_PATH);
    sendReconnectMessage(F("❌ Не удалось скачать архив (связь или нехватка памяти).\n"
                           "Попробуйте ещё раз, а если повторится — перезагрузите систему "
                           "и повторите отправку."), g_gzOtaUser);
    return;
  }

  sendReconnectMessage("🗜️ Скачано " + String(dl) + " Б, распаковываю и прошиваю...", g_gzOtaUser);
  String diag;
  bool ok = gzOtaFlash(diag);
  SD.remove(GZ_TMP_PATH);  // архив больше не нужен в любом случае

  if (ok) {
    sendReconnectMessage(F("✅ Обновление применено, перезагрузка..."), g_gzOtaUser);
    // 📮 Обязательно ДО рестарта: иначе Telegram отдаст сообщение с архивом
    //    снова, и устройство будет обновляться по кругу. Сохраняем позицию
    //    очереди в EEPROM и подтверждаем её серверу запросом getUpdates.
    telegramSaveUpdateOffset();
    bot.tickManual();
    delay(500);
    ESP.restart();
  } else {
    // 🔍 Диагностика в чат: логи в рабочей прошивке отключены, иначе причину не узнать
    sendReconnectMessage("❌ Не удалось применить .gz: " + diag +
                         "\nПришлите обычный DripIrrigation.ino.bin", g_gzOtaUser);
  }
}

// 📊 rm()/fileToGraf()/fileToGrafPeriod() вынесены в reports.cpp

// 🔮 Предварительное объявление обработчика сообщений (FastBot2 callback)
void newMsg(fb::Update& u);
void loadUsers();

// ============================================================
// 🚀 Инициализация Telegram бота (FastBot2)
// ============================================================
void botInit() {
  // 🔐 Токен берём из botToken — он уже разрешён в systemInit
  //    (EEPROM → secrets.h → ввод через портал)
  if (!botTokenValid(botToken)) {
    LOG_E("Токен бота не задан — бот не запущен (полив работает автономно)");
    return;
  }
  bot.setToken(botToken);

  // ⏭️ Пропускаем накопившиеся сообщения.
  //    Важно: skipUpdates(-1) очередь НЕ чистит — по API Telegram отрицательный
  //    offset возвращает ПОСЛЕДНИЙ апдейт. После перезагрузки это ровно то
  //    сообщение, что перезагрузку и вызвало (файл прошивки) — и обновление
  //    зацикливалось. Поэтому продолжаем с сохранённой позиции очереди.
  uint32_t savedOffset = 0;
  EEPROM.begin(4096);
  EEPROM.get(EEPROM_UPD_ID_ADDR, savedOffset);
  EEPROM.end();

  if (savedOffset && savedOffset != 0xFFFFFFFFul) {
    bot.skipUpdates((int32_t)savedOffset);
    LOG_I("Очередь Telegram: продолжаем с update_id %u", savedOffset);
  } else {
    bot.skipUpdates();  // 🆕 первый запуск — стандартное поведение
  }

  // 📎 Подключаем обработчик входящих обновлений (FastBot2 стиль)
  bot.attachUpdate(newMsg);

  bot.setPollMode(fb::Poll::Long, 60000);

  // 🔌 Подключаем контроль связи с Telegram (детект разрыва/восстановления)
  botMonitorAttach();

  // 📥 Загружаем зарегистрированных пользователей из EEPROM
  loadUsers();
  LOG_I("Telegram-бот запущен (long-poll 60 с)");
}

// ============================================================
// 👥 Классы для управления пользователями и действиями
// ============================================================

// 👥 Модель пользователей (User, массив, find/add/removeUser, save/loadUsersData)
//    вынесена в users.h / users.cpp. Здесь остаётся только презентация бота.

// 📡 Транспорт (sendReconnectMessage/sendStatus/dropCDCard/
//    connectCDCard) вынесён в bot_transport.cpp.

// ============================================================
// 🎬 Установить текущее действие пользователя (конечный автомат)
// ============================================================
void actionSet(String userID, int action) {
  User* u = findUser(userID);
  if (u != nullptr) u->action = action;
}

// ============================================================
// 📥 Загрузка списка пользователей из EEPROM при старте
// ============================================================
// 📮 Последний обработанный update_id (обновляется в newMsg)
static uint32_t g_lastUpdateId = 0;

// 📮 Сохранить позицию очереди Telegram перед перезагрузкой.
//    Telegram считает апдейт доставленным только после запроса со следующим
//    offset. При перезагрузке сразу после команды (особенно OTA) подтверждения
//    не происходит, и сообщение приходит снова — обновление зацикливается.
//    Сохранённая позиция восстанавливается в botInit.
void telegramSaveUpdateOffset() {
  if (!g_lastUpdateId) return;

  uint32_t next = g_lastUpdateId + 1;
  EEPROM.begin(4096);
  EEPROM.put(EEPROM_UPD_ID_ADDR, next);
  EEPROM.commit();
  EEPROM.end();
  LOG_I("Очередь Telegram: сохранена позиция %u", next);
}

// 🆘 Аварийное меню: единственное действие — перезагрузка. Показывается вместо
//    обычного интерфейса, пока какая-то плата не отвечает.
static void showFaultMenu(fb::Update& u, const String& userID) {
  fb::InlineKeyboard menu;
  menu.addButton("🔄 Перезагрузка", "/Restart", fb::KeyStyle::Danger);
  showMenu(u, userID, hwFaultReport(), menu);
}

// 📨 Разослать отчёт об авариях всем пользователям (один раз на поломку)
void hwReportToChat() {
  if (!hwHasFault() || hwReportSent()) return;

  String report = hwFaultReport();
  for (uint8_t i = 0; i < userCount; i++) {
    fb::InlineKeyboard menu;
    menu.addButton("🔄 Перезагрузка", "/Restart", fb::KeyStyle::Danger);

    fb::Message msg;
    msg.text = report;
    msg.chatID = users[i].userID;
    msg.setModeHTML();
    msg.setKeyboard(&menu);
    bot.sendMessage(msg);
  }
  hwMarkReportSent();
  LOG_W("Отчёт об авариях отправлен в чат");
}

void loadUsers() {
  loadUsersData();  // 📥 данные грузим из EEPROM (модуль users)
  LOG_D("Рассылка стартового меню: %d польз.", userCount);

  // 🆘 Железо не в порядке — вместо обычного приветствия шлём отчёт об авариях
  //    с единственной кнопкой перезагрузки.
  if (hwHasFault()) {
    hwReportToChat();
    return;
  }

  // 🎹 Каждому загруженному пользователю — приветствие с версией прошивки и меню.
  //    Версия в старте позволяет убедиться, что OTA действительно применилась.
  for (uint8_t i = 0; i < userCount; i++) {
    User* u = &users[i];
    sendReconnectMessage("🚀 Система запущена! Прошивка v" FW_VERSION, u->userID);

    fb::InlineKeyboard menu;
    buildMainMenu(menu, u->role < 2);

    fb::Message msg;
    msg.text = "🚀 <b>Запуск</b>";
    msg.chatID = u->userID;
    msg.setModeHTML();
    msg.setKeyboard(&menu);
    bot.sendMessage(msg);
  }
}

// ============================================================
// 🔍 Массив для операции поиска датчика (временные значения АЦП)
// ============================================================
int search[NUM_CHANNELS] = { 0 };

// ============================================================
// 🤖 ГЛАВНЫЙ ОБРАБОТЧИК СООБЩЕНИЙ TELEGRAM (FastBot2)
// ============================================================
void newMsg(fb::Update& u) {
  // 📮 Запоминаем позицию в очереди: пригодится, если обработка команды
  //    закончится перезагрузкой (OTA, «Перезагрузка») — см. telegramSaveUpdateOffset
  g_lastUpdateId = u.id();

  // 📥 Получаем объект сообщения из обновления
  fb::MessageRead msg = u.message();

  // 📝 Извлекаем данные из сообщения (FastBot2 API)
  String chatID = msg.chat().id().toString();   // 💬 ID чата
  String userID = msg.from().id().toString();   // 👤 ID пользователя
  String username = msg.from().username().toString();  // 🏷️ Имя пользователя
  String text = msg.text().toString();           // 💬 Текст сообщения


  // 🔘 Проверяем, является ли это callback query (нажатие inline-кнопки)
  String data = "";
  if (u.isQuery()) {
    fb::QueryRead q = u.query();
    data = q.data().toString();
    userID = q.from().id().toString();
    chatID = q.message().chat().id().toString();
  }

  // 🖨️ Отладочный вывод в Serial
  LOG_D("Msg %s (%s): '%s' data='%s' [%s]", userID.c_str(), username.c_str(),
        text.c_str(), data.c_str(), u.isQuery() ? "query" : "message");

  // ============================================================
  // 🆕 ПЕРВИЧНАЯ РЕГИСТРАЦИЯ: если нет пользователей — первый вводит кодовое слово
  // ============================================================
  if (userCount == 0) {
    if (text == String(tstr)) {
      // ✅ Кодовое слово совпало — регистрируем как владельца (роль 0)
      fb::Message reply;
      reply.text = "👑 Привет, владелец системы!";
      reply.chatID = chatID;
      reply.reply.messageID = msg.id().toInt();  // 📎 Ответ на конкретное сообщение
      bot.sendMessage(reply);

      addUser(userID, 0);
      saveUsers();
    } else {
      fb::Message reply;
      reply.text = "🔐 Первый запрос должен быть с ключевым словом, полученным при настройке WiFi";
      reply.chatID = chatID;
      reply.reply.messageID = msg.id().toInt();
      bot.sendMessage(reply);
    }
    return;
  }

  // ============================================================
  // 👤 ПРОВЕРКА РЕГИСТРАЦИИ ПОЛЬЗОВАТЕЛЯ
  // ============================================================
  if (findUser(userID) != nullptr) {
    User* check_user = findUser(userID);
    String command = "";

    // 🔘 Если это callback query — берём data, иначе текст сообщения
    if (u.isQuery()) {
      command = data;
      // ✅ Автоматически отвечаем на callback query (FastBot2 autoQuery по умолчанию)
    } else {
      command = text;
    }

    // ============================================================
    // 🎬 ОБРАБОТКА АКТИВНЫХ ДЕЙСТВИЙ (конечный автомат диалогов)
    // ============================================================
    {
      User* act = check_user;  // 🎬 состояние диалога хранится в самом пользователе

      // 🔙 Сброс действия при получении команды
      if (command.startsWith("/")) {
        act->action = Dlg::None;
      }
      // 🔧 Калибровка: этап 3 — завершение (1130–1137)
      else if (act->action >= Dlg::CalibFinish && act->action <= Dlg::CalibFinish + Dlg::Last) {
        int ind = act->action - Dlg::CalibFinish;
        if (btnIs(text, "ЗАВЕРШИТЬ")) {
          if (abs(hs.getHigh(ind) - hs.getLow(ind)) < 100) {
            // kbRem=true — убираем reply-клавиатуру «ЗАВЕРШИТЬ/ОТМЕНА», иначе она
            // остаётся внизу экрана после выхода из калибровки
            sendReconnectMessage("❌ Ошибка калибровки датчик № " + chanLabel(ind) + " — слишком малое значение!\nОтменяем...", userID, true);
            hs.setLowHighValue(ind, myConfig.chanel[ind].minVal, myConfig.chanel[ind].maxVal);
            command = F("/Calibrate");
          } else {
            sendReconnectMessage("✅ Калибровка завершена! Датчик № " + chanLabel(ind) + " полностью функционален!", userID, true);
            myConfig.chanel[ind].maxVal = hs.getHigh(ind);
            myConfig.chanel[ind].minVal = hs.getLow(ind);
            needUpdate = true;
          }
          act->action = Dlg::None;
          command = F("/Calibrate");
        } else {
          sendReconnectMessage(F("❌ Калибровка отменена!"), userID, true);
          hs.setLowHighValue(ind, myConfig.chanel[ind].minVal, myConfig.chanel[ind].maxVal);
          command = F("/Calibrate");
          act->action = Dlg::None;
        }
      }
      // 🔧 Калибровка: этап 2 — сухое значение (1120–1127)
      else if (act->action >= Dlg::CalibDry && act->action <= Dlg::CalibDry + Dlg::Last) {
        int ind = act->action - Dlg::CalibDry;
        if (btnIs(text, "ДАЛЕЕ")) {
          hs.setAll();
          int val = hs.setHigh(ind);
          LOG_D("Сухое значение, датчик %d: %d", ind, val);
          sendReconnectMessage("🌵 Установите датчик № " + chanLabel(ind) + " в почву и нажмите завершить!", userID);

          fb::Keyboard kb;
          kb.addButton("✅ ЗАВЕРШИТЬ").addButton("❌ ОТМЕНА");
          fb::Message m;
          m.text = "<Калибровка>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          act->action = Dlg::CalibFinish + ind;
          return;
        } else {
          sendReconnectMessage(F("❌ Калибровка отменена!"), userID, true);
          hs.setLowHighValue(ind, myConfig.chanel[ind].minVal, myConfig.chanel[ind].maxVal);
          command = F("/Calibrate");
          act->action = Dlg::None;
        }
      }
      // 🔧 Калибровка: этап 1 — влажное значение (1110–1117)
      else if (act->action >= Dlg::CalibWet && act->action <= Dlg::CalibWet + Dlg::Last) {
        int ind = act->action - Dlg::CalibWet;
        if (btnIs(text, "ДАЛЕЕ")) {
          hs.setAll();
          int val = hs.setLow(ind);
          LOG_D("Влажное значение, датчик %d: %d", ind, val);
          act->action = Dlg::CalibDry + ind;
          sendReconnectMessage("🌵 Достаньте датчик № " + chanLabel(ind) + " из воды, протрите и нажмите далее!", userID);

          fb::Keyboard kb;
          kb.addButton("➡️ ДАЛЕЕ").addButton("❌ ОТМЕНА");
          fb::Message m;
          m.text = "<Калибровка>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          return;
        } else {
          sendReconnectMessage(F("❌ Калибровка отменена!"), userID, true);
          hs.setLowHighValue(ind, myConfig.chanel[ind].minVal, myConfig.chanel[ind].maxVal);
          command = F("/Calibrate");
          act->action = Dlg::None;
        }
      }
      // 🔧 Калибровка: этап 0 — старт (1100–1107)
      else if (act->action >= Dlg::CalibStart && act->action <= Dlg::CalibStart + Dlg::Last) {
        if (btnIs(text, "СТАРТ")) {
          int ind = act->action - Dlg::CalibStart;
          sendReconnectMessage("💧 Положите датчик № " + chanLabel(ind) + " в воду и нажмите далее!", userID);

          fb::Keyboard kb;
          kb.addButton("➡️ ДАЛЕЕ").addButton("❌ ОТМЕНА");
          fb::Message m;
          m.text = "<Калибровка>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          act->action = Dlg::CalibWet + ind;
          return;
        } else {
          sendReconnectMessage(F("❌ Калибровка отменена!"), userID, true);
          command = F("/Calibrate");
          act->action = Dlg::None;
        }
      }
      // 🔍 Поиск датчика: этап 0 — старт (3000)
      else if (act->action == Dlg::SearchStart) {
        if (btnIs(text, "СТАРТ")) {
          sendReconnectMessage("💧 Положите датчик в воду и нажмите далее!", userID);

          fb::Keyboard kb;
          kb.addButton("➡️ ДАЛЕЕ").addButton("❌ ОТМЕНА");
          fb::Message m;
          m.text = "<Поиск>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          act->action = Dlg::SearchWet;
          return;
        } else {
          sendReconnectMessage(F("❌ Поиск отменён!"), userID, true);
          command = F("/control");
          act->action = Dlg::None;
        }
      }
      // 🔍 Поиск датчика: этап 1 — влажное значение (3010)
      else if (act->action == Dlg::SearchWet) {       
        if (btnIs(text, "ДАЛЕЕ")) {
          hs.setAll();
          for (int i = 0; i < NUM_CHANNELS; i++) {
            search[i] = hs.getCurrent(i);
          }
          sendReconnectMessage("🌵 Достаньте датчик из воды, протрите и нажмите далее!", userID);

          fb::Keyboard kb;
          kb.addButton("➡️ ДАЛЕЕ").addButton("❌ ОТМЕНА");
          fb::Message m;
          m.text = "<Поиск>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          act->action = Dlg::SearchDetect;
          return;
        } else {
          sendReconnectMessage(F("❌ Поиск отменён!"), userID, true);
          command = F("/control");
          act->action = Dlg::None;
        }
      }
      // 🔍 Поиск датчика: этап 2 — определение (3020)
      else if (act->action == Dlg::SearchDetect) {
        if (btnIs(text, "ДАЛЕЕ")) {
          hs.setAll();
          int ind = -1;
          for (int i = 0; i < NUM_CHANNELS; i++) {
            if (abs(search[i] - hs.getCurrent(i)) > 300) {
              ind = i;
              break;
            }
          }
          if (ind < 0) {
            sendReconnectMessage(F("❌ Не удалось определить датчик! Повторите операцию."), userID, true);
          } else {
            sendReconnectMessage("🔍 Предположительно ваш датчик № " + String(ind + 1) + " (" + myConfig.chanel[ind].title + ")!", userID, true);
          }
        } else {
          sendReconnectMessage(F("❌ Поиск отменён!"), userID, true);
        }
        command = F("/control");
        act->action = Dlg::None;
      }
      // 🎯 Установка порога влажности (1400–1407)
      else if (act->action >= Dlg::Border && act->action <= Dlg::Border + Dlg::Last) {
        int ind = act->action - Dlg::Border;
        String input = String(text);
        if (isNumeric(input)) {
          int num = input.toInt();
          if (num >= 0 && num <= 100) {
            act->action = Dlg::None;
            myConfig.chanel[ind].border = num;
            needUpdate = true;
            sendReconnectMessage("✅ Порог клапана № " + String(ind + 1) + " установлен: " + String(num) + " %", userID);
            command = "/Borders";
          } else {
            sendReconnectMessage(F("❌ Ожидалось значение (от 0 до 100) % !"), userID);
            return;
          }
        }
      }
      // 📝 Переименование датчика (1200–1207)
      else if (act->action >= Dlg::Rename && act->action <= Dlg::Rename + Dlg::Last) {
        int ind = act->action - Dlg::Rename;
        // 🛡️ text — произвольный ввод из Telegram (до 4096 байт), а title — буфер
        // фиксированного размера char[90]: strcpy без ограничения переполнил бы его
        // и повредил соседние поля Config. Также убираем запятую/перевод строки
        // (ломают формат CSV-логов, reports.cpp разбирает их по запятой) и
        // < > & (title потом вставляется в HTML-режимные сообщения бота — сырые
        // угловые скобки/амперсанд ломают разбор HTML на стороне Telegram).
        String safe = text;
        safe.replace(",", " ");
        safe.replace("\n", " ");
        safe.replace("\r", " ");
        safe.replace("<", "‹");
        safe.replace(">", "›");
        safe.replace("&", "и");
        strncpy(myConfig.chanel[ind].title, safe.c_str(), sizeof(myConfig.chanel[ind].title) - 1);
        myConfig.chanel[ind].title[sizeof(myConfig.chanel[ind].title) - 1] = '\0';
        command = F("/Namings");
        act->action = Dlg::None;
        needUpdate = true;
        sendReconnectMessage("✅ Датчик № " + String(ind + 1) + " переименован: " + safe, userID);
      }
      // 🚰 Установка режима работы клапана (1300–1307)
      else if (act->action >= Dlg::ModeSet && act->action <= Dlg::ModeSet + Dlg::Last) {
        int ind = act->action - Dlg::ModeSet;
        if (btnIs(text, "ВКЛ.")) {
          sendReconnectMessage(F("✅ Клапан включён!"), userID, true);
          myConfig.chanel[ind].mode = Mode::AlwaysOn;
          valveOpen(ind);
        } else if (btnIs(text, "ВЫКЛ.")) {
          sendReconnectMessage(F("⛔ Клапан выключен!"), userID, true);
          myConfig.chanel[ind].mode = Mode::AlwaysOff;
          valveClose(ind);
        } else if (btnIs(text, "АВТО")) {
          sendReconnectMessage(F("🤖 Клапан в автоматическом режиме!"), userID, true);
          myConfig.chanel[ind].mode = Mode::Auto;
        } else if (btnIs(text, "А.П.")) {
          sendReconnectMessage(F("🏠 Клапан в автоматическом режиме для парника!"), userID, true);
          myConfig.chanel[ind].mode = Mode::Greenhouse;
        }
        needUpdate = true;
        act->action = Dlg::None;
        command = F("/OperationMode");
      }
      // 🚰 Установка режима для ВСЕХ клапанов (1399)
      else if (act->action == Dlg::ModeSetAll) {
        uint8_t md = Mode::Auto;
        if (btnIs(text, "ВКЛ.")) {
          sendReconnectMessage(F("✅ Клапаны включены!"), userID, true);
          md = Mode::AlwaysOn;
        } else if (btnIs(text, "ВЫКЛ.")) {
          sendReconnectMessage(F("⛔ Клапаны выключены!"), userID, true);
          md = Mode::AlwaysOff;
        } else if (btnIs(text, "АВТО")) {
          sendReconnectMessage(F("🤖 Клапаны в автоматическом режиме!"), userID, true);
          md = Mode::Auto;
        } else if (btnIs(text, "А.П.")) {
          sendReconnectMessage(F("🏠 Клапаны в автоматическом режиме для парника!"), userID, true);
          md = Mode::Greenhouse;
        }
        for (int l = 0; l < NUM_CHANNELS; l++) {
          myConfig.chanel[l].mode = md;
          if (md == Mode::AlwaysOn) {
            valveOpen(l);
          }
          if (md == Mode::AlwaysOff) {
            valveClose(l);
          }
        }
        needUpdate = true;
        act->action = Dlg::None;
        command = F("/OperationMode");
      }
      // 🔧 Ручная калибровка (1800–1807)
      else if (act->action >= Dlg::CalibManual && act->action <= Dlg::CalibManual + Dlg::Last) {
        int ind = act->action - Dlg::CalibManual;
        String minvs = getValue(text, ',', 0);
        String maxvs = getValue(text, ',', 1);

        if (isNumeric(minvs) && isNumeric(maxvs)) {
          int minv = minvs.toInt();
          int maxv = maxvs.toInt();
          if (minv >= 0 && minv <= 4096 && maxv >= 0 && maxv <= 4096) {
            act->action = Dlg::None;
            hs.setLowHighValue(ind, minv, maxv);
            command = "/CalibrateManual";
            myConfig.chanel[ind].maxVal = hs.getHigh(ind);
            myConfig.chanel[ind].minVal = hs.getLow(ind);
            needUpdate = true;
            sendReconnectMessage("✅ Калибровка датчика № " + chanLabel(ind) + " сохранена (мин " + String(minv) + ", макс " + String(maxv) + ")", userID);
          } else {
            sendReconnectMessage(F("❌ Ожидалось значение (от 0 до 4096)!"), userID);
            return;
          }
        } else {
          sendReconnectMessage(F("❌ Ожидалось значение в формате (целое,целое)!"), userID);
          return;
        }
      }
      // 🔄 Сброс настроек (2000)
      else if (act->action == Dlg::Reset) {
        act->action = Dlg::None;
        if (btnIs(text, "ДА")) {
          myConfig.deltaCalibration = 15;
          myConfig.deltaHum = 5;
          myConfig.runOnNight = false;
          myConfig.runOnRain = true;
          myConfig.boostPumpValves = 9;  // 💪 насос давления по умолчанию выключен
          myConfig.clogThresholdPercent = 50;  // 🧽 порог контроля фильтра
          myConfig.flowMonitorEnabled = true;  // 🧽 контроль фильтра включён
          myConfig.tgTimeoutSec = TG_TIMEOUT_DEFAULT;  // 🔌 таймаут связи Telegram
          myConfig.autoCalNoDelay = false;   // 🔧 авто-калибровка с подтверждением (безопасный режим)
          myConfig.cleanFlowPerValve = 0.0;  // 🧽 сброс эталона фильтра (на клапан)
          myConfig.cleanFlowDrain = 0.0;     // 🧽 сброс эталона фильтра (дренаж)
          hs.setBorder(myConfig.deltaCalibration);
          for (int i = 0; i < NUM_CHANNELS; i++) {
            myConfig.chanel[i].border = 60;
            myConfig.chanel[i].maxVal = 1024;
            myConfig.chanel[i].minVal = 1024;
            myConfig.chanel[i].mode = Mode::Auto;
            strcpy(myConfig.chanel[i].title, String("🌱 Растение").c_str());
            // 🔧 Синхронизируем датчики с конфигом: раньше сбрасывался только
            // myConfig, а объект hs держал в RAM СТАРЫЕ границы — проценты
            // считались по ним до перезагрузки, а авто-калибровка могла записать
            // эти старые границы обратно в конфиг, отменив сброс.
            hs.setLowHighValue(i, myConfig.chanel[i].minVal, myConfig.chanel[i].maxVal);
          }
          LOG_W("Сброс настроек к значениям по умолчанию (выполнил %s)", username.c_str());
          sendReconnectMessage(F("✅ Сброс выполнен!"), userID, true);
        } else {
          sendReconnectMessage(F("❌ Сброс отменён!"), userID, true);
        }
        command = "/configure";
        needUpdate = true;
      }
      // 🔄 Перезагрузка (1)
      else if (act->action == Dlg::Restart) {
        act->action = Dlg::None;
        if (btnIs(text, "ДА")) {
          LOG_W("Запрошена перезагрузка устройства (%s)", username.c_str());
          res = 1;
          sendReconnectMessage(F("🔄 Перезагрузка начата!"), userID, true);
          return;
        } else {
          sendReconnectMessage(F("❌ Перезагрузка отменена!"), userID, true);
          return;
        }
      }
      // Стереь все данные по проливу
      else if (act->action == Dlg::ClearFlow) {
        act->action = Dlg::None;
        if (btnIs(text, "ДА")) {
          clearDataFlow();
          sendReconnectMessage(F("🔄 Данные стерты!"), userID, true);
          return;
        } else {
          sendReconnectMessage(F("❌ Отмена!"), userID, true);
          return;
        }
      }
      // ⚡ Авто-калибровка без задержки (1009)
      else if (act->action == Dlg::AutoCalNoDly) {
        act->action = Dlg::None;
        if (btnIs(text, "ДА")) {
          myConfig.autoCalNoDelay = true;
          sendReconnectMessage(F("⚡ Авто-калибровка без задержки включена — граница сдвигается сразу по первому замеру за ней (выбросы АЦП не фильтруются)."), userID, true);
        } else {
          myConfig.autoCalNoDelay = false;
          sendReconnectMessage("🛡️ Авто-калибровка с подтверждением — граница сдвигается, только если превышение держится " + String(HUM_AUTOCAL_CONFIRM) + " замера подряд (" + String(HUM_AUTOCAL_CONFIRM) + " мин).", userID, true);
        }
        command = "/configure";
        needUpdate = true;
      }
      // 🌙 Работа ночью (1001)
      else if (act->action == Dlg::WorkNight) {
        act->action = Dlg::None;
        if (btnIs(text, "ДА")) {
          myConfig.runOnNight = true;
          sendReconnectMessage(F("🌙 Работа ночью включена!"), userID, true);
        } else {
          myConfig.runOnNight = false;
          sendReconnectMessage(F("🌙 Работа ночью выключена!"), userID, true);
        }
        command = "/configure";
        needUpdate = true;
      }
      // 🌧️ Работа под дождём (1002)
      else if (act->action == Dlg::WorkRain) {
        act->action = Dlg::None;
        if (btnIs(text, "ДА")) {
          myConfig.runOnRain = true;
          sendReconnectMessage(F("🌧️ Работа под дождём включена!"), userID);
        } else {
          myConfig.runOnRain = false;
          sendReconnectMessage(F("🌧️ Работа под дождём выключена!"), userID);
        }
        command = "/configure";
        needUpdate = true;
      }
      // 📁 Отправка файла по дате (5000)
      else if (act->action == Dlg::SendFile) {
        String input = String(text);
        String sd = getValue(input, '.', 0);
        String sm = getValue(input, '.', 1);
        String sy = getValue(input, '.', 2);

        String fn = String("/") + sy + String("/") + sm + String("/") + sd + String(".csv");

        if (SD.exists(fn)) {
          File file = SD.open(fn, FILE_READ);
          if (!file) {
            sendReconnectMessage(F("❌ Файл не открывается"), userID);
            LOG_W("Не удалось открыть файл");
          } else {
            sendReconnectMessage(F("📁 Файл открывается, ждите ..."), userID);
            fn.replace("/", "_");

            fb::File fmsg(fn, fb::File::Type::document, file);
            fmsg.chatID = chatID;
            bot.sendFile(fmsg);
          }
          file.close();
          return;
        } else {
          sendReconnectMessage(F("❌ Файл не найден"), userID);
          command = "/reports";
        }
        act->action = Dlg::None;
      }
      // 📊 График за период (5200)
      else if (act->action == Dlg::GraphPeriod) {
        String input = String(text);
        if (isNumeric(input)) {
          int num = input.toInt();
          if (num >= 1 && num <= 60) {
            act->action = Dlg::None;
            fileToGrafPeriod(num, userID);
            command = "/Graphics";
          } else {
            sendReconnectMessage(F("❌ Ожидалось значение (от 0 до 60)!"), userID);
            return;
          }
        } else {
          LOG_D("Некорректный ввод пользователя");
          sendReconnectMessage(F("❌ Ожидался ввод целого числа — повторите!"), userID);
          return;
        }
      }
      // 📊 График за конкретную дату (5100)
      else if (act->action == Dlg::GraphDate) {
        String input = String(text);
        String sd = getValue(input, '.', 0);
        String sm = getValue(input, '.', 1);
        String sy = getValue(input, '.', 2);

        String fn = String("/") + sy + String("/") + sm + String("/") + sd + String(".csv");

        if (SD.exists(fn)) {
          fileToGraf(fn, userID);
        } else {
          sendReconnectMessage(F("❌ Файл не найден"), userID);
        }
        act->action = Dlg::None;
        command = "/Graphics";
      }
      // 🗑️ Удаление папки года (1005)
      else if (act->action == Dlg::DelFolder) {
        String input = String(text);
        if (isNumeric(input)) {
          Datime t = getDateTime();
          if (t.year == input.toInt()) {
            LOG_D("Некорректный ввод пользователя");
            sendReconnectMessage(F("❌ Удалять текущий год запрещено!"), userID);
            return;
          }
          String del = "/" + input;
          if (!SD.exists(del)) {
            LOG_D("Некорректный ввод пользователя");
            sendReconnectMessage(F("❌ Записей запрашиваемого года не найдено!"), userID);
            act->action = Dlg::None;
            command = "/configure";
          } else {
            File dir = SD.open(del);
            sendReconnectMessage(F("🗑️ Началось удаление файлов, ожидайте..."), userID);
            rm(dir, del + "/");
            dir.close();
            SD.rmdir(del);
            command = "/configure";
            act->action = Dlg::None;
          }
        } else {
          LOG_D("Некорректный ввод пользователя");
          sendReconnectMessage(F("❌ Ожидался ввод года!"), userID);
          return;
        }
      }
      // 💧 Дельта влажности (1003)
      else if (act->action == Dlg::DeltaHum) {
        String input = String(text);
        if (isNumeric(input)) {
          int num = input.toInt();
          if (num >= 0 && num <= 100) {
            act->action = Dlg::None;
            myConfig.deltaHum = num;
            needUpdate = true;
            sendReconnectMessage("✅ Дельта влажности: " + String(num) + " %", userID);
            command = "/configure";
          } else {
            sendReconnectMessage(F("❌ Ожидалось значение (от 0 до 100) % !"), userID);
            return;
          }
        } else {
          LOG_D("Некорректный ввод пользователя");
          sendReconnectMessage(F("❌ Ожидался ввод целого числа — повторите!"), userID);
          return;
        }
      }
      // 🔧 Дельта калибровки (1004)
      else if (act->action == Dlg::DeltaCalib) {
        String input = String(text);
        if (isNumeric(input)) {
          int num = input.toInt();
          if (num >= 0 && num <= 2048) {
            act->action = Dlg::None;
            myConfig.deltaCalibration = num;
            needUpdate = true;
            hs.setBorder(myConfig.deltaCalibration);
            sendReconnectMessage("✅ Дельта калибровки: " + String(num), userID);
            command = "/configure";
          } else {
            sendReconnectMessage(F("❌ Ожидалось значение (от 0 до 2048)!"), userID);
            return;
          }
        } else {
          LOG_D("Некорректный ввод пользователя");
          sendReconnectMessage(F("❌ Ожидался ввод целого числа — повторите!"), userID);
          return;
        }
      }
      // 💪 Насос повышения давления (1006): порог открытых клапанов 1..8, 9 = выкл
      else if (act->action == Dlg::BoostPump) {
        String input = String(text);
        if (isNumeric(input)) {
          int num = input.toInt();
          if (num >= 1 && num <= 9) {
            act->action = Dlg::None;
            myConfig.boostPumpValves = num;
            needUpdate = true;
            stopPumpIfNeed();  // 💪 применяем порог сразу (вкл/выкл без переоткрытия клапана)
            sendReconnectMessage(num >= 9 ? String("✅ Насос давления: выключен")
                                          : "✅ Насос давления: включать при ≥ " + String(num) + " клапанах", userID);
            command = "/configure";
          } else {
            sendReconnectMessage(F("❌ Ожидалось значение от 1 до 9!"), userID);
            return;
          }
        } else {
          LOG_D("Некорректный ввод пользователя");
          sendReconnectMessage(F("❌ Ожидался ввод целого числа — повторите!"), userID);
          return;
        }
      }
      // 🧽 Порог тревоги засора фильтра (1007): 10..90 %
      else if (act->action == Dlg::ClogThreshold) {
        String input = String(text);
        if (isNumeric(input)) {
          int num = input.toInt();
          if (num >= 10 && num <= 90) {
            act->action = Dlg::None;
            myConfig.clogThresholdPercent = num;
            needUpdate = true;
            sendReconnectMessage("✅ Контроль фильтра: тревога при потоке ниже " + String(num) + " % от нормы", userID);
            command = "/configure";
          } else {
            sendReconnectMessage(F("❌ Ожидалось значение от 10 до 90 %!"), userID);
            return;
          }
        } else {
          LOG_D("Некорректный ввод пользователя");
          sendReconnectMessage(F("❌ Ожидался ввод целого числа — повторите!"), userID);
          return;
        }
      }
      // 🔌 Таймаут связи с Telegram (1008): 120..3600 с
      else if (act->action == Dlg::TgTimeout) {
        String input = String(text);
        if (isNumeric(input)) {
          int num = input.toInt();
          if (num >= 120 && num <= 3600) {
            act->action = Dlg::None;
            myConfig.tgTimeoutSec = num;
            needUpdate = true;
            sendReconnectMessage("✅ Таймаут связи Telegram: " + String(num) + " с", userID);
            command = "/configure";
          } else {
            sendReconnectMessage(F("❌ Ожидалось значение от 120 до 3600 с!"), userID);
            return;
          }
        } else {
          LOG_D("Некорректный ввод пользователя");
          sendReconnectMessage(F("❌ Ожидался ввод целого числа — повторите!"), userID);
          return;
        }
      }
    }

    // ============================================================
    // 📤 OTA ОБНОВЛЕНИЕ (только для владельца системы)
    // ============================================================
    // 📝 Проверяем наличие документа (файла) в сообщении
    if (msg.hasDocument() && check_user->role < 1) {
      fb::DocumentRead doc = msg.document();
      String fileName = doc.name().toString();
      OtaKind kind = otaKindOf(fileName);
      if (kind == OtaKind::Bin) {
        // 📥 Обычный бинарник — штатный OTA библиотеки (пишет во flash как есть).
        //    Позицию очереди фиксируем ЗАРАНЕЕ: прошивку применяет и перезагружает
        //    сама библиотека, и без этого после старта прилетит тот же файл.
        LOG_W("OTA .bin от %s (%s)", username.c_str(), fileName.c_str());
        telegramSaveUpdateOffset();
        bot.updateFlash(u.message().document(), u.message().chat().id());
        return;
      } else if (kind == OtaKind::Gz) {
        // 🗜️ Сжатый бинарник — запоминаем file_id, распаковку+прошивку сделает
        // telegramGzOtaTick() из loop() (нельзя качать внутри колбэка tick).
        LOG_W("OTA .gz от %s (%s) — запланирована распаковка", username.c_str(), fileName.c_str());
        telegramSaveUpdateOffset();  // 📮 чтобы архив не пришёл повторно после рестарта
        doc.id().toString(g_gzOtaId);
        g_gzOtaUser = userID;
        g_gzOtaPending = true;
        sendReconnectMessage(F("📥 Архив принят, начинаю обновление..."), userID);
        return;
      } else {
        // 🛡️ Имя файла — внешние данные, чистим спецсимволы HTML перед вставкой
        String safeName = fileName;
        safeName.replace("<", "‹");
        safeName.replace(">", "›");
        safeName.replace("&", "и");
        sendReconnectMessage("❓ Это не похоже на прошивку: " + safeName +
                             "\nЖду файл DripIrrigation.ino.bin или DripIrrigation.ino.bin.gz", chatID);
      }
    } else if (msg.hasDocument()) {
      sendReconnectMessage("⛔ Только владелец системы может отправлять обновления устройства", chatID);
    }

    // ============================================================
    // 📋 ОБРАБОТКА КОМАНД (начинающихся с /)
    // ============================================================
    if (command[0] == '/') {
      // 🆘 Аварийный режим: пока плата не отвечает, обычный интерфейс скрыт.
      //    Управлять поливом и менять настройки с неисправным железом нельзя,
      //    поэтому на любую команду показываем отчёт и одну кнопку «Перезагрузка».
      //    Пропускаем сам /Restart (иначе перезагрузиться было бы нечем) и OTA —
      //    неисправность может лечиться новой прошивкой.
      if (hwHasFault() && command != "/Restart") {
        showFaultMenu(u, userID);
        return;
      }

      // 👑 Команды только для владельца (role == 0)
      if (check_user->role == 0) {
        // (в данной версии нет специфичных команд только для владельца)
      }

      // 🎭 Команды для администраторов (role < 2)
      if (check_user->role < 2) {
        // 🔄 Сброс всех настроек
        if (command == "/DropSettings") {
          sendReconnectMessage(F("⚠️ Сбросить все настройки в значение по умолчанию?"), userID);

          fb::Keyboard kb;
          kb.addButton("✅ ДА").addButton("❌ НЕТ");
          fb::Message m;
          m.text = "<Сброс>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          actionSet(userID, Dlg::Reset);
        }
        // 🔧 Ручная калибровка конкретного датчика
        else if (command.startsWith("/HumidityMCalibrate")) {
          String prob = getValue(command, '_', 1);
          int ind = prob.toInt();
          if (!validChannelIndex(ind, userID)) return;
          sendReconnectMessage("🔧 Введите минимальное и максимальное значение датчика № " + chanLabel(ind) + " в формате: целое,целое.\nТекущее: [" + String(hs.getLow(ind)) + "; " + String(hs.getHigh(ind)) + "]", userID);
          actionSet(userID, Dlg::CalibManual + ind);
        }
        // 🔧 Автоматическая калибровка конкретного датчика
        else if (command.startsWith("/HumidityCalibrate")) {
          String prob = getValue(command, '_', 1);
          int ind = prob.toInt();
          if (!validChannelIndex(ind, userID)) return;
          sendReconnectMessage("💧 Подготовьте ёмкость с водой и впитывающую салфетку в зоне доступа датчика.\n🚀 Запустить калибровку датчика № " + chanLabel(ind) + "?", userID);

          fb::Keyboard kb;
          kb.addButton("🚀 СТАРТ").addButton("❌ ОТМЕНА");
          fb::Message m;
          m.text = "<Калибровка>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          actionSet(userID, Dlg::CalibStart + ind);
        }
        // 🔧 Меню калибровки
        else if (command == "/Calibrate") {
          fb::InlineKeyboard menu;
          for (int i = 0; i < NUM_CHANNELS; i++) {
            menu.addButton("🌱 Датчик №" + chanLabel(i), "/HumidityCalibrate_" + String(i), fb::KeyStyle::Primary).newRow();
          }
          menu.addButton("🔙 Назад", "/Configure", fb::KeyStyle::Default);
          showMenu(u, userID, "🔧 <b>Калибровка</b>", menu);
        }
        // 🔧 Ручная калибровка (меню)
        else if (command == "/CalibrateManual") {
          hs.setAll();
          fb::InlineKeyboard menu;
          for (int i = 0; i < NUM_CHANNELS; i++) {
            String btnText = "🌱 №" + chanLabel(i) + " [" + String(hs.getLow(i)) + ";" + String(hs.getHigh(i)) + "] " + String(hs.Percent(i)) + "%";
            menu.addButton(btnText, "/HumidityMCalibrate_" + String(i), fb::KeyStyle::Primary).newRow();
          }
          menu.addButton("🔙 Назад", "/Configure", fb::KeyStyle::Default);
          showMenu(u, userID, "🔧 <b>Ручная Калибровка</b>", menu);
        }
        // 🗑️ Удаление папки года
        else if (command == "/DelFolder") {
          sendReconnectMessage(F("📅 Введите год удаления (формат YYYY):"), userID);
          actionSet(userID, Dlg::DelFolder);
        }
        // 🔧 Дельта калибровки
        else if (command == "/DeltaCalibration") {
          sendReconnectMessage(F("🔧 Введите значение (от 0 до 2048):"), userID);
          actionSet(userID, Dlg::DeltaCalib);
        }
        // 💧 Дельта влажности
        else if (command == "/DeltaHumidity") {
          sendReconnectMessage(F("💧 Введите значение (от 0 до 100) %:"), userID);
          actionSet(userID, Dlg::DeltaHum);
        }
        // 💪 Насос повышения давления
        else if (command == "/BoostPump") {
          sendReconnectMessage(F("💪 При скольких открытых клапанах включать насос повышения давления?\n"
                                 "1–8 — порог (включать при ≥ N открытых), 9 — никогда:"), userID);
          actionSet(userID, Dlg::BoostPump);
        }
        // 🧽 Порог контроля засора фильтра
        else if (command == "/ClogThreshold") {
          sendReconnectMessage(F("🧽 Порог = % от скорости ЧИСТОГО фильтра, НИЖЕ которого подаётся тревога.\n"
                                 "Чем меньше число — тем сильнее должен засориться фильтр.\n"
                                 "• 50 % — поток упал до половины (вдвое медленнее)\n"
                                 "• 30 % — поток упал до 30 % от нормы (сильный засор)\n"
                                 "Введите значение от 10 до 90 %:"), userID);
          actionSet(userID, Dlg::ClogThreshold);
        }
        // 🧽 Фильтр прочищен — сброс эталона и тревоги
        else if (command == "/FilterClean") {
          flowMonitorRecalibrate();
          sendReconnectMessage(F("🧽 Принято! Эталон потока сброшен — система заново измерит «чистую» скорость в ближайших поливах."), userID);
        }
        // 🔌 Таймаут потери связи с Telegram
        else if (command == "/TgTimeout") {
          sendReconnectMessage(F("🔌 Через сколько секунд без связи с Telegram считать её потерянной?\n"
                                 "Введите значение (от 120 до 3600 с):"), userID);
          actionSet(userID, Dlg::TgTimeout);
        }
        // 🌧️ Работа под дождём
        else if (command == "/WorkAtRain") {
          sendReconnectMessage(F("🌧️ Включить режим работы во время дождя?"), userID);

          fb::Keyboard kb;
          kb.addButton("✅ ДА").addButton("❌ НЕТ");
          fb::Message m;
          m.text = "<Включить>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          actionSet(userID, Dlg::WorkRain);
        }
        // 🌙 Работа ночью
        else if (command == "/WorkAtNight") {
          sendReconnectMessage(F("🌙 Включить режим работы в ночное время?"), userID);

          fb::Keyboard kb;
          kb.addButton("✅ ДА").addButton("❌ НЕТ");
          fb::Message m;
          m.text = "<Включить>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          actionSet(userID, Dlg::WorkNight);
        }
        // ⚡ Авто-калибровка границ без задержки
        else if (command == "/AutoCalNoDelay") {
          sendReconnectMessage("⚡ Авто-калибровка границ датчиков влажности.\n\n"
                               "Если показание вышло за границу калибровки, граница раздвигается.\n"
                               "• ДА — двигать сразу, по первому же замеру (быстро, но разовый выброс АЦП испортит калибровку)\n"
                               "• НЕТ — двигать только если превышение держится " + String(HUM_AUTOCAL_CONFIRM) + " замера подряд (" + String(HUM_AUTOCAL_CONFIRM) + " мин) — выбросы отфильтровываются\n\n"
                               "Включить режим без задержки?", userID);

          fb::Keyboard kb;
          kb.addButton("✅ ДА").addButton("❌ НЕТ");
          fb::Message m;
          m.text = "<Без задержки>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          actionSet(userID, Dlg::AutoCalNoDly);
        }
        // ⚙️ Главное меню настроек. Ловим оба написания: "/Configure" приходит
        // с inline-кнопок, "/configure" — редирект после текстовых диалогов.
        else if (command == "/Configure" || command == "/configure") {
          String boostText = myConfig.boostPumpValves >= 9
                               ? String("выкл")
                               : String("при ≥ ") + String(myConfig.boostPumpValves) + " кл.";
          String menuText = "🔧 <b>Настройка</b>\n"
                          "🌙 Работа ночью " + String(myConfig.runOnNight ? "[✅]" : "[❌]") + "\n"
                          "🌧️ Работа под дождём " + String(myConfig.runOnRain ? "[✅]" : "[❌]") + "\n"
                          "💧 Дельта влажности % (" + String(myConfig.deltaHum) + ")\n"
                          "🔧 Дельта калибровки (" + String(myConfig.deltaCalibration) + ")\n"
                          "⚡ Авто-калибровка без задержки " + String(myConfig.autoCalNoDelay ? "[✅]" : "[❌]") + "\n"
                          "💪 Насос давления (" + boostText + ")\n"
                          "🧽 Контроль фильтра (тревога ниже " + String(myConfig.clogThresholdPercent) + "% нормы)\n"
                          "🔌 Таймаут связи Telegram (" + String(myConfig.tgTimeoutSec) + " с)";

          fb::InlineKeyboard menu;
          menu.addButton("🌙 Работа ночью", "/WorkAtNight", fb::KeyStyle::Primary).newRow()
              .addButton("🌧️ Работа под дождём", "/WorkAtRain", fb::KeyStyle::Primary).newRow()
              .addButton("💧 Дельта влажности", "/DeltaHumidity", fb::KeyStyle::Primary).newRow()
              .addButton("🔧 Дельта калибровки", "/DeltaCalibration", fb::KeyStyle::Primary).newRow()
              .addButton("⚡ Авто-калибровка без задержки", "/AutoCalNoDelay", fb::KeyStyle::Primary).newRow()
              .addButton("💪 Насос давления", "/BoostPump", fb::KeyStyle::Primary).newRow()
              .addButton("🧽 Порог фильтра", "/ClogThreshold", fb::KeyStyle::Primary).newRow()
              .addButton("🧽 Фильтр прочищен", "/FilterClean", fb::KeyStyle::Success).newRow()
              .addButton("🔌 Таймаут Telegram", "/TgTimeout", fb::KeyStyle::Primary).newRow()
              .addButton("🔧 Калибровка", "/Calibrate", fb::KeyStyle::Primary).newRow()
              .addButton("🔧 Ручная калибровка", "/CalibrateManual", fb::KeyStyle::Primary).newRow()
              .addButton("🔄 Сброс настроек", "/DropSettings", fb::KeyStyle::Danger).newRow()
              .addButton("🗑️ Удаление файлов", "/DelFolder", fb::KeyStyle::Danger).newRow()
              .addButton("🔙 Назад", "/Start", fb::KeyStyle::Default);
          showMenu(u, userID, menuText, menu);
        }
        // 🔄 Перезагрузка системы
        else if (command == "/Restart") {
          for (uint8_t i = 0; i < userCount; i++) {
            User* user = &users[i];
            sendReconnectMessage("🔄 Система будет перезагружена!", user->userID);
          }

          fb::Keyboard kb;
          kb.addButton("✅ ДА").addButton("❌ НЕТ");
          fb::Message m;
          m.text = "<Перезагрузка>";
          m.chatID = chatID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          actionSet(userID, Dlg::Restart);
        }
        // 👥 Меню управления пользователями
        else if (command == "/Users") {
          fb::InlineKeyboard menu;
          menu.addButton("📋 Список", "/UsersList", fb::KeyStyle::Primary).newRow()
              .addButton("⬆️ Повышение", "/UsersUpEdit", fb::KeyStyle::Success).newRow()
              .addButton("⬇️ Понижение", "/UsersDownEdit", fb::KeyStyle::Danger).newRow()
              .addButton("🗑️ Удаление", "/UsersDelete", fb::KeyStyle::Danger).newRow()
              .addButton("🔙 Назад", "/Start", fb::KeyStyle::Default);
          showMenu(u, userID, "👥 <b>Пользователи</b>", menu);
        }
        // 📋 Список пользователей
        else if (command == "/UsersList") {
          for (uint8_t i = 0; i < userCount; i++) {
            User* user = &users[i];
            sendReconnectMessage("👤 Пользователь ID: " + user->userID + "\n🎭 Роль: " + user->role, chatID);
          }
        }
        // ⬇️ Меню понижения прав
        else if (command == "/UsersDownEdit") {
          fb::InlineKeyboard menu;
          bool hasUsers = false;
          for (uint8_t i = 0; i < userCount; i++) {
            User* user = &users[i];
            if (user->role == 1) {
              menu.addButton(user->userID, "/DownGradeUser_" + user->userID, fb::KeyStyle::Danger);
              hasUsers = true;
            }
          }
          if (!hasUsers) {
            sendReconnectMessage("ℹ️ Нет пользователей для понижения", userID);
            command = "/Users";
          } else {
            menu.newRow().addButton("🔙 Назад", "/Users", fb::KeyStyle::Default);

            fb::Message m;
            m.text = "⬇️ <b>Понижение</b>";
            m.chatID = userID;
            m.setModeHTML();
            m.setKeyboard(&menu);
            bot.sendMessage(m);
            LOG_D("Меню понижения пользователей");
          }
        }
        // ⬆️ Меню повышения прав
        else if (command == "/UsersUpEdit") {
          fb::InlineKeyboard menu;
          bool hasUsers = false;
          for (uint8_t i = 0; i < userCount; i++) {
            User* user = &users[i];
            if (user->role > 1) {
              menu.addButton(user->userID, "/GradeUser_" + user->userID, fb::KeyStyle::Success);
              hasUsers = true;
            }
          }
          if (!hasUsers) {
            sendReconnectMessage("ℹ️ Нет пользователей для повышения", userID);
            command = "/Users";
          } else {
            menu.newRow().addButton("🔙 Назад", "/Users", fb::KeyStyle::Default);

            fb::Message m;
            m.text = "⬆️ <b>Повышение</b>";
            m.chatID = userID;
            m.setModeHTML();
            m.setKeyboard(&menu);
            bot.sendMessage(m);
            LOG_D("Меню повышения пользователей");
          }
        }
        // 🗑️ Меню удаления пользователей
        else if (command == "/UsersDelete") {
          fb::InlineKeyboard menu;
          bool hasUsers = false;
          for (uint8_t i = 0; i < userCount; i++) {
            User* user = &users[i];
            if (user->role > 0) {
              menu.addButton(user->userID, "/RemoveUser_" + user->userID, fb::KeyStyle::Danger);
              hasUsers = true;
            }
          }
          if (!hasUsers) {
            sendReconnectMessage("ℹ️ Нет пользователей для удаления", userID);
            command = "/Users";
          } else {
            menu.newRow().addButton("🔙 Назад", "/Users", fb::KeyStyle::Default);

            fb::Message m;
            m.text = "🗑️ <b>Удаление</b>";
            m.chatID = userID;
            m.setModeHTML();
            m.setKeyboard(&menu);
            bot.sendMessage(m);
            LOG_D("Меню удаления пользователей");
          }
        }
        // ➕ Добавить пользователя
        else if (command.startsWith("/AddUser")) {
          String userId = getValue(command, '_', 1);
          if (findUser(userId) != nullptr) {
            sendReconnectMessage("❌ Данный пользователь уже есть в системе!", chatID);
          } else if (addUser(userId, 2)) {
            sendReconnectMessage("✅ Вас добавил " + username + " в систему как пользователя!", userId);
            sendReconnectMessage("✅ Регистрация пользователя успешно завершена!", chatID);
            saveUsers();
          } else {
            sendReconnectMessage("❌ Достигнут лимит пользователей (" + String(MAX_USERS) + ")!", chatID);
          }
        }
        // ⬆️ Повысить пользователя до админа
        else if (command.startsWith("/GradeUser")) {
          String userId = getValue(command, '_', 1);
          User* user = findUser(userId);
          if (user != nullptr) {
            if (user->role < 2) {
              sendReconnectMessage("ℹ️ Пользователь с ID " + userId + " уже администратор", chatID);
            } else {
              user->role = 1;
              LOG_W("Привилегии: %s повышен до администратора (кем: %s)", user->userID.c_str(), username.c_str());
              sendReconnectMessage("⬆️ Вас повысил " + username + " — вы теперь администратор!", user->userID);
              sendReconnectMessage("✅ Повышение пользователя " + user->userID + " успешно завершено!", chatID);
              saveUsers();
            }
          } else {
            sendReconnectMessage("❌ Пользователя с ID " + userId + " не найдено", chatID);
          }
        }
        // ⬇️ Понизить пользователя до обычного
        else if (command.startsWith("/DownGradeUser")) {
          String userId = getValue(command, '_', 1);
          User* user = findUser(userId);
          if (user != nullptr) {
            if (user->role == 2) {
              sendReconnectMessage("ℹ️ Пользователь с ID " + userId + " уже пользователь", chatID);
            } else {
              user->role = 2;
              LOG_I("Привилегии: %s понижен до пользователя (кем: %s)", user->userID.c_str(), username.c_str());
              sendReconnectMessage("⬇️ Вас понизил " + username + " — вы теперь пользователь!", user->userID);
              sendReconnectMessage("✅ Понижение пользователя " + user->userID + " успешно завершено!", chatID);
              saveUsers();
            }
          } else {
            sendReconnectMessage("❌ Пользователя с ID " + userId + " не найдено", chatID);
          }
        }
        // 🗑️ Удалить пользователя
        else if (command.startsWith("/RemoveUser")) {
          String userId = getValue(command, '_', 1);
          User* user = findUser(userId);
          if (user != nullptr) {
            if (user->role == 0) {
              sendReconnectMessage("⛔ Нельзя удалять главного администратора", chatID);
            } else {
              sendReconnectMessage("🗑️ Вас удалил " + username + " из системы!", user->userID);
              sendReconnectMessage("✅ Удаление пользователя " + user->userID + " успешно завершено!", chatID);
              removeUser(userId);
              saveUsers();  // 🔧 фикс: раньше удаление не сохранялось в EEPROM
            }
          } else {
            sendReconnectMessage("❌ Пользователя с ID " + userId + " не найдено", chatID);
          }
        }
      }

      // ============================================================
      // 📋 КОМАНДЫ ДОСТУПНЫ ВСЕМ ЗАРЕГИСТРИРОВАННЫМ ПОЛЬЗОВАТЕЛЯМ
      // ============================================================
      // 🚰 Пролив дренажа
      if (command == "/Spillage") {
        spillage();
      }
      // 🎯 Установка порога влажности для клапана
      else if (command.startsWith("/BordersSet")) {
        String prob = getValue(command, '_', 1);
        int ind = prob.toInt();
        if (!validChannelIndex(ind, userID)) return;
        sendReconnectMessage(("🎯 Введите % порога срабатывания клапана № " + String((ind + 1)) + ":"), userID);
        actionSet(userID, Dlg::Border + ind);
      }
      // 📝 Переименование датчика
      else if (command.startsWith("/NamingsSet")) {
        String prob = getValue(command, '_', 1);
        int ind = prob.toInt();
        if (!validChannelIndex(ind, userID)) return;
        sendReconnectMessage(("📝 Введите название датчика № " + String((ind + 1)) + ":"), userID);
        actionSet(userID, Dlg::Rename + ind);
      }
      // 🚰 Установка режима работы клапана
      else if (command.startsWith("/OperationModeSet")) {
        String prob = getValue(command, '_', 1);
        int ind = prob.toInt();
        if (!validChannelIndex(ind, userID)) return;
        sendReconnectMessage(F("🚰 Выберите режим работы!"), userID);

        fb::Keyboard kb;
        kb.addButton("✅ ВКЛ.").addButton("⛔ ВЫКЛ.").newRow()
            .addButton("🤖 АВТО").addButton("🏠 А.П.");
        fb::Message m;
        m.text = "<Режим>";
        m.chatID = userID;
        m.setKeyboard(&kb);
        bot.sendMessage(m);


        actionSet(userID, Dlg::ModeSet + ind);
      }
      // 🚰 Установка режима для ВСЕХ клапанов
      else if (command == "/AllOperationModeSet") {
        sendReconnectMessage(F("🚰 Выберите режим работы для всех клапанов!"), userID);

        fb::Keyboard kb;
        kb.addButton("✅ ВКЛ.").addButton("⛔ ВЫКЛ.").newRow()
            .addButton("🤖 АВТО").addButton("🏠 А.П.");
        fb::Message m;
        m.text = "<Режим>";
        m.chatID = userID;
        m.setKeyboard(&kb);
        bot.sendMessage(m);

        actionSet(userID, Dlg::ModeSetAll);
      }
      // ⬆️ Запрос на повышение прав
      else if (command == "/GradeMeUp") {
        for (uint8_t i = 0; i < userCount; i++) {
          User* user = &users[i];
          if (user->role < 2) {
            sendReconnectMessage("👤 Пользователь: " + username + " ID: " + userID + " просит поднять его в правах.\n/GradeUser_" + userID, user->userID);
          }
        }
        sendReconnectMessage("⏳ Ваша регистрация принята, ожидайте ответа от администратора", chatID);
      }
      // 🏠 Главное меню ("/Start" — с inline-кнопок, "/start" — команда Telegram)
      else if (command == "/Start" || command == "/start") {
        fb::InlineKeyboard menu;
        buildMainMenu(menu, check_user->role < 2);
        showMenu(u, userID, "🚀 <b>Запуск</b>", menu);
      }
      // 📝 Меню переименования датчиков
      else if (command == "/Namings") {
        fb::InlineKeyboard menu;
        for (int i = 0; i < NUM_CHANNELS; i++) {
          String btnText = "🌱 Датчик №" + String(i + 1) + " (" + String(myConfig.chanel[i].title) + ")";
          menu.addButton(btnText, "/NamingsSet_" + String(i), fb::KeyStyle::Primary).newRow();
        }
        menu.addButton("🔙 Назад", "/Control", fb::KeyStyle::Default);
        showMenu(u, userID, "📝 <b>Именование</b>", menu);
      }
      // 🎯 Меню установки порогов влажности
      else if (command == "/Borders") {
        fb::InlineKeyboard menu;
        for (int i = 0; i < NUM_CHANNELS; i++) {
          String btnText = "🚰 Клапан №" + String(i + 1) + " (" + String(myConfig.chanel[i].title) + ") <" + String(myConfig.chanel[i].border) + " %>";
          menu.addButton(btnText, "/BordersSet_" + String(i), fb::KeyStyle::Primary).newRow();
        }
        menu.addButton("🔙 Назад", "/Control", fb::KeyStyle::Default);
        showMenu(u, userID, "🎯 <b>Пороги срабатывания</b>", menu);
      }
      // 🚰 Меню режимов работы клапанов
      else if (command == "/OperationMode") {
        fb::InlineKeyboard menu;
        for (int i = 0; i < NUM_CHANNELS; i++) {
          String modeSymbol;
          if (myConfig.chanel[i].mode == Mode::Auto) modeSymbol = "➖";
          else if (myConfig.chanel[i].mode == Mode::AlwaysOn) modeSymbol = "✅";
          else if (myConfig.chanel[i].mode == Mode::AlwaysOff) modeSymbol = "⛔";
          else modeSymbol = "🏠";

          String btnText = "🚰 Клапан №" + String(i + 1) + " (" + String(myConfig.chanel[i].title) + ") [" + modeSymbol + "]";
          menu.addButton(btnText, "/OperationModeSet_" + String(i), fb::KeyStyle::Primary).newRow();
        }
        menu.addButton("🚰 Установить для всех", "/AllOperationModeSet", fb::KeyStyle::Success).newRow()
            .addButton("🔙 Назад", "/Control", fb::KeyStyle::Default);
        showMenu(u, userID, "🚰 <b>Режим работы</b>", menu);
      }
      // 📊 Вывод текущего статуса системы
      else if (command == "/status") {
        hs.setAll();
        String status = String("ℹ️ <b>Общий статус</b>  <i>v" FW_VERSION "</i>\n\n");
        status = status + String("📅 <b>Текущая дата и время:</b> ") + getDateTime().toString(' ');
        status = status + String("\n\n") + String(nightNow ? "🌙 Сейчас ночь" : "☀️ Сейчас день");
        status = status + String(rainNow ? ", 🌧️ идёт дождь" : ", ☀️ дождя нет");
        status = status + String("\n");
        status = status + String("\n📊 <b>Информация по датчикам</b>");
        for (int i = 0; i < NUM_CHANNELS; i++) {
          status = status + String("\n");
          status = status + String("\n🌱 Канал № ") + String((i + 1)) + String(" (") + String(myConfig.chanel[i].title) + String(")");
          if (check_user->role == 0) {
            status = status + String("\n📟 Текущее значение АЦП: ") + String(hs.getCurrent(i));
          }
          status = status + String("\n💧 Текущая влажность: ") + String(hs.Percent(i)) + String(" %");
          status = status + String("\n🎯 Граничное значение: ") + String(myConfig.chanel[i].border) + String(" %");
          status = status + String("\n🚰 Клапан: ") + String((oldMode[i] == VState::ForcedClose || oldMode[i] == VState::CloseByHum) ? "⛔ закрыт" : oldMode[i] == VState::Hysteresis ? "➖ без контроля" : "✅ открыт");
          status = status + String("\n⚙️ Режим: ") + String(myConfig.chanel[i].mode == Mode::Auto ? "🤖 автоматический" : myConfig.chanel[i].mode == Mode::AlwaysOn ? "✅ постоянно открыт"
                                                                                      : myConfig.chanel[i].mode == Mode::AlwaysOff ? "⛔ постоянно закрыт"
                                                                                                                     : "🏠 автоматический (парник)");
        }
        // 💧 Добавляем информацию о расходе воды
        status = status + String("\n");
        status = status + String("\n💧 <b>Расход воды</b>");
        status = status + String("\n📟 За текущую сессию: ") + String(flowGetSessionLiters(), 3) + String(" л");
        status = status + String("\n📊 Общий расход: ") + String(flowGetTotalLiters(), 3) + String(" л");

        // 🧽 Контроль засора фильтра
        status = status + String("\n");
        status = status + String("\n🧽 <b>Фильтр</b>");
        uint8_t openNow = countValveOpen();
        status = status + String("\n📟 Скорость потока: ") + String(fmLastRate(), 2) + String(" л/мин");
        float fmBase = fmBaselineFor(openNow);
        if (openNow >= 1 && fmBase > 0.0) {
          status = status + String("\n📊 Эталон (") + String(openNow) + String(" кл.): ") + String(fmBase, 2) + String(" л/мин");
        }
        status = status + String("\n🎯 Тревога при потоке ниже ") + String(myConfig.clogThresholdPercent) + String(" % от нормы");
        status = status + String("\n") + String(fmIsClogged() ? "⚠️ Похоже, фильтр засорён — прочистите!" : "✅ Фильтр в норме");

        // 💪 Насос повышения давления: фактическое состояние + причина + настройка
        status = status + String("\n");
        status = status + String("\n💪 <b>Насос давления</b>");
        String pumpNow;
        if (!pumpIsOn()) {
          pumpNow = F("⛔ выключен");
        } else if (valveIsDraining()) {
          pumpNow = F("⚡ работает — пролив дренажа");
        } else if (pumpStart != 0) {
          pumpNow = F("⚡ работает — пусковой режим (30 с)");
        } else {
          pumpNow = F("⚡ работает — по порогу открытых клапанов");
        }
        status = status + String("\n📟 Сейчас: ") + pumpNow;
        status = status + String("\n🎯 Настройка: ") + (myConfig.boostPumpValves >= 9
                              ? String("только пусковые 30 с")
                              : String("держать при ≥ ") + String(myConfig.boostPumpValves) + " откр. кл.");

        LOG_D("Свободная память: %u байт", ESP.getFreeHeap());
        int mem = ESP.getFreeHeap() / 1024;
        status = status + String("\n");
        status = status + String("\n💾 <b>Оставшаяся память:</b> ") + String(mem) + " Kb";
        sendReconnectMessage(status, userID);
      }
      // 🔍 Поиск датчика
      else if (command == "/Searching") {
        sendReconnectMessage(F("🔍 Произойдёт поиск датчика. Подготовьте ёмкость с водой и впитывающую салфетку в зоне доступа датчика.\n🚀 Запустить поиск датчика?"), userID);

        fb::Keyboard kb;
        kb.addButton("🚀 СТАРТ").addButton("❌ ОТМЕНА");
        fb::Message m;
        m.text = "<Поиск>";
        m.chatID = userID;
        m.setKeyboard(&kb);
        bot.sendMessage(m);

        actionSet(userID, Dlg::SearchStart);
      }
      // 💧 Команда отображения расхода воды
      else if (command == "/WaterFlow") {
        String flowMsg = String("💧 <b>Расход воды</b>\n\n");
        flowMsg = flowMsg + String("📟 За текущую сессию полива: ") + String(flowGetSessionLiters(), 3) + String(" л\n");
        flowMsg = flowMsg + String("📊 Общий расход за все время: ") + String(flowGetTotalLiters(), 3) + String(" л\n");
        flowMsg = flowMsg + String("🔄 Импульсов датчика: ") + String(flowPulseCount) + String(" шт.\n");

        // 🩺 Диагностика датчика: при капельном поливе расход может быть ниже порога
        // страгивания крыльчатки — тогда импульсов нет вовсе и это надо видеть явно,
        // а не гадать по нулевым литрам (нулевые литры бывают и при закрытых клапанах).
        flowMsg = flowMsg + String("\n🩺 <b>Диагностика датчика</b>\n");
        unsigned long silence = flowMsSinceLastPulse();
        if (silence == 0xFFFFFFFFUL) {
          flowMsg = flowMsg + String("⚠️ Импульсов не было ни разу с момента включения\n");
        } else {
          flowMsg = flowMsg + String("⏱️ Последний импульс: ") + String(silence / 1000.0, 1) + String(" с назад\n");
        }
        float inst = flowInstantRate();
        flowMsg = flowMsg + String("📟 Мгновенный поток: ") + String(inst, 3) + String(" л/мин");
        if (inst > 0.0) {
          flowMsg = flowMsg + String(" (") + String(inst * 1000.0 / 60.0, 0) + String(" мл/с)");
        }
        flowMsg = flowMsg + String("\n📉 Порог датчика: ") + String(FLOW_PULSES_PER_LITER, 0) + String(" имп./л");
        flowMsg = flowMsg + String("\n🚰 Открытых клапанов: ") + String(countValveOpen());


        fb::InlineKeyboard menu;
        menu.addButton("🗑️ Стереть данные пролива", "/WaterSpillage", fb::KeyStyle::Danger);
        
        fb::Message m;
        m.text = flowMsg;
          m.chatID = userID;
          m.setModeHTML();
          m.setKeyboard(&menu);
          bot.sendMessage(m);
      }
      // 💧 Команда отображения расхода воды
      else if (command == "/WaterSpillage") {
          sendReconnectMessage(F("⚠️ Сбросить все данные о проливе в системе?"), userID);

          fb::Keyboard kb;
          kb.addButton("✅ ДА").addButton("❌ НЕТ");
          fb::Message m;
          m.text = "<Сброс>";
          m.chatID = userID;
          m.setKeyboard(&kb);
          bot.sendMessage(m);

          actionSet(userID, Dlg::ClearFlow);
        
      }
      // ⚙️ Меню управления ("/Control" — с inline-кнопок, "/control" —
      // редирект после текстовых диалогов поиска датчика)
      else if (command == "/Control" || command == "/control") {
        fb::InlineKeyboard menu;
        menu.addButton("🚰 Режим работы", "/OperationMode", fb::KeyStyle::Primary).newRow()
            .addButton("📝 Названия", "/Namings", fb::KeyStyle::Primary).newRow()
            .addButton("🎯 Пороги срабатывания", "/Borders", fb::KeyStyle::Primary).newRow()
            .addButton("💧 Расход воды", "/WaterFlow", fb::KeyStyle::Primary).newRow()
            .addButton("🗑️ Пролив дренажа", "/Spillage", fb::KeyStyle::Danger).newRow()
            .addButton("🔍 Поиск датчика", "/Searching", fb::KeyStyle::Primary).newRow()
            .addButton("🔙 Назад", "/Start", fb::KeyStyle::Default);
        showMenu(u, userID, "⚙️ <b>Управление</b>", menu);
      }
      // 🔕 Пауза статусных сообщений
      else if (command == "/pause") {
        check_user->messages = false;
        sendReconnectMessage(F("🔕 Отключены все статусные сообщения"), userID);
      }
      // 🔔 Возобновление статусных сообщений
      else if (command == "/continue") {
        check_user->messages = true;
        sendReconnectMessage(F("🔔 Статусные сообщения активированы"), userID);
      }
      // 📊 График за вчера
      else if (command == "/GraphicsYesterday") {
        Datime t(getDateTime().getUnix() - 60 * 60 * 24);
        String fn = "/" + String(t.year) + "/" + IntWith2Zero(t.month) + "/" + IntWith2Zero(t.day) + ".csv";
        if (SD.exists(fn)) {
          fileToGraf(fn, userID);
        } else {
          sendReconnectMessage(F("❌ Файл за вчера не найден"), userID);
        }
        command = "/Graphics";
      }
      // 📊 График за сегодня
      else if (command == "/GraphicsToday") {
        Datime t = getDateTime();
        String fn = "/" + String(t.year) + "/" + IntWith2Zero(t.month) + "/" + IntWith2Zero(t.day) + ".csv";
        if (SD.exists(fn)) {
          fileToGraf(fn, userID);
        } else {
          sendReconnectMessage(F("❌ Файл за сегодня не найден"), userID);
        }
        command = "/Graphics";
      }
      // 📊 График за период (запрос дней)
      else if (command == "/GraphicsPeriod") {
        sendReconnectMessage(F("📅 Введите число дней, за которые хотите отобразить график"), userID);
        actionSet(userID, Dlg::GraphPeriod);
      }
      // 📊 График за конкретную дату
      else if (command == "/GraphicsTo") {
        sendReconnectMessage(F("📅 Введите дату в формате dd.mm.yyyy, за которую хотите отобразить график"), userID);
        actionSet(userID, Dlg::GraphDate);
      }
      // 📁 Файл за конкретную дату
      else if (command == "/FileTo") {
        sendReconnectMessage(F("📅 Введите дату в формате dd.mm.yyyy, за которую хотите получить файл"), userID);
        actionSet(userID, Dlg::SendFile);
      }
      // 📁 Файл за сегодня
      else if (command == "/FileToday") {
        Datime t = getDateTime();
        String fn = "/" + String(t.year) + "/" + IntWith2Zero(t.month) + "/" + IntWith2Zero(t.day) + ".csv";
        if (SD.exists(fn)) {
          File file = SD.open(fn, FILE_READ);
          if (!file) {
            LOG_W("Не удалось открыть файл");
            sendReconnectMessage(F("❌ Файл не открывается"), userID);
          } else {
            sendReconnectMessage(F("📁 Файл открывается, ждите ..."), userID);
            fn.replace("/", "_");

            fb::File fmsg(fn, fb::File::Type::document, file);
            fmsg.chatID = chatID;
            bot.sendFile(fmsg);
          }
          file.close();
        } else {
          sendReconnectMessage(F("❌ Файл за сегодня не найден"), userID);
          command = "/reports";
        }
      }
      // 📁 Файл за вчера
      else if (command == "/FileYesterday") {
        Datime t(getDateTime().getUnix() - 60 * 60 * 24);
        String fn = "/" + String(t.year) + "/" + IntWith2Zero(t.month) + "/" + IntWith2Zero(t.day) + ".csv";
        if (SD.exists(fn)) {
          File file = SD.open(fn, FILE_READ);
          if (!file) {
            LOG_W("Не удалось открыть файл");
            sendReconnectMessage(F("❌ Файл не открывается"), userID);
          } else {
            sendReconnectMessage(F("📁 Файл открывается, ждите ..."), userID);
            fn.replace("/", "_");

            fb::File fmsg(fn, fb::File::Type::document, file);
            fmsg.chatID = chatID;
            bot.sendFile(fmsg);
          }
          file.close();
        } else {
          sendReconnectMessage(F("❌ Файл за вчера не найден"), userID);
          command = "/reports";
        }
      }
      // 📊 График за декаду
      else if (command == "/GraphicsDecade") {
        fileToGrafPeriod(10, userID);
        command = "/Graphics";
      }

      // 📈 Меню отчётов. Отдельный if (не else-if): сюда попадают и редиректы,
      // выставленные выше по цепочке (например, «файл не найден» → "/reports").
      if (command == "/reports" || command == "/Reports") {
        fb::InlineKeyboard menu;
        menu.addButton("📊 Графики", "/Graphics", fb::KeyStyle::Primary).newRow()
            .addButton("📁 Файл за вчера", "/FileYesterday", fb::KeyStyle::Primary).newRow()
            .addButton("📁 Файл текущий", "/FileToday", fb::KeyStyle::Primary).newRow()
            .addButton("📁 Файл...", "/FileTo", fb::KeyStyle::Primary).newRow()
            .addButton("🔙 Назад", "/Start", fb::KeyStyle::Default);
        showMenu(u, userID, "📈 <b>Отчёты</b>", menu);
      }
      // 📊 Меню графиков (аналогично — ловит редиректы "/Graphics" из цепочки)
      if (command == "/Graphics") {
        fb::InlineKeyboard menu;
        menu.addButton("📊 График за вчера", "/GraphicsYesterday", fb::KeyStyle::Primary).newRow()
            .addButton("📊 График за сегодня", "/GraphicsToday", fb::KeyStyle::Primary).newRow()
            .addButton("📊 График за декаду", "/GraphicsDecade", fb::KeyStyle::Primary).newRow()
            .addButton("📊 График за период", "/GraphicsPeriod", fb::KeyStyle::Primary).newRow()
            .addButton("📊 График...", "/GraphicsTo", fb::KeyStyle::Primary).newRow()
            .addButton("🔙 Назад", "/Reports", fb::KeyStyle::Default);
        showMenu(u, userID, "📊 <b>Графики</b>", menu);
      }
    }
    // ============================================================
    // ❌ НЕКОМАНДНОЕ СООБЩЕНИЕ (не начинается с /)
    // ============================================================
    else {
      fb::Message reply;
      reply.text = "🤖 Бот распознаёт только команды, начинающиеся с символа '/'";
      reply.chatID = chatID;
      reply.reply.messageID = msg.id().toInt();
      bot.sendMessage(reply);
    }
  }
  // ============================================================
  // 👤 НЕЗАРЕГИСТРИРОВАННЫЙ ПОЛЬЗОВАТЕЛЬ
  // ============================================================
  else {
    if (text == "/register") {
      for (uint8_t i = 0; i < userCount; i++) {
        User* user = &users[i];
        if (user->role < 2) {
          sendReconnectMessage("👤 Пользователь: " + username + " ID: " + userID + " просит зарегистрировать его.\n/AddUser_" + userID, user->userID);
        }
      }
      sendReconnectMessage("⏳ Ваша регистрация принята, ожидайте ответа от администратора", chatID);
    } else {
      fb::Message reply;
      reply.text = "🔒 Только зарегистрированные пользователи могут общаться со мной. Если хотите зарегистрироваться — пришлите запрос: /register";
      reply.chatID = chatID;
      reply.reply.messageID = msg.id().toInt();
      bot.sendMessage(reply);
    }
  }
}