#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>

// переключатель режимов: TEST (true) / Готовое изделие (false); чтобы не жечь "EEPROM"
#define TEST_MODE true  // false, когда будешь готов к "боевому" железу.

// --- Точные настройки пинов ---
const int FLOW_SENSOR_PIN = 2; // Синяя кнопка / Датчик Холла (D2 -> GND)
const int BUTTON_MODE_PIN = 3; // Черная кнопка MODE (листает меню) (D3 -> GND)
const int BUTTON_RESET_PIN = 4; // КРАСНАЯ КНОПКА СБРОСА/сохранения  (D4 -> GND)
const int BUTTON_UP_PIN = 5; // Кнопка ВВЕРХ Up (D5 -> GND)
const int BUTTON_DOWN_PIN = 6; // Кнопка ВНИЗ Down (D6 -> GND)
const int LED_PIN = 13; // Встроенный светодиод паники/потока

// --- Калибровка расхода и ресурс, для меню "6" и "8" ---
float calibrationFactor = 0.04500;      // Теперь это переменная (по умолчанию 450), для теста 0.04500
float totalResourceLiters = 10000.0; // Теперь это тоже настраиваемая переменная

// --- Адреса в EEPROM ---
const int EEPROM_ADDR_LITERS = 0;     // счетчик ресурса установленного картриджа, литры
const int EEPROM_ADDR_TOTAL = 4;      // тотальный счетчик, литры
const int EEPROM_ADDR_INIT = 10;
const int EEPROM_ADDR_CALIB = 14;     // Калибровка
const int EEPROM_ADDR_DAYS = 18;      // Хранение ресурса по сроку (дней) (int)
const int EEPROM_ADDR_PERIODS = 20;   // Хранение 4-часовых окон (int)
const int EEPROM_ADDR_RESOURCE = 22;  // Настраиваемый ресурс картриджа

const int EEPROM_ADDR_TOTAL_DAYS = 26; // Глобальный счетчик дней

const int EEPROM_INIT_KEY = 42;

// --- Переменные для прерываний ---
volatile unsigned long pulseCount = 0;
volatile bool isFlowing = false;
volatile unsigned long lastPulseTime = 0;

volatile unsigned long flowPulsesSec = 0;
unsigned long lastFlowMillis = 0;
float currentFlowRate = 0.0;

// --- Переменные основного цикла ---
float litersPassed = 0.0;
float totalLitersPassed = 0.0;
float currentResource = totalResourceLiters;
unsigned long lastEepromWriteTime = 0;
bool needEepromWrite = false;

// --- ОПТИМИЗИРОВАННЫЙ ТАЙМЕР (4-ЧАСОВЫЕ ОКНА) ---
int daysPassed = 0;

int totalDaysPassed = 0; // <--- НОВАЯ ПЕРЕМЕННАЯ

int periodsAccumulated = 0;
unsigned long lastPeriodMillis = 0;
const unsigned long SAVE_PERIOD = 100UL; // 14400000UL (4 часа, в симуляторе ставь 10UL для теста)

// --- Состояния кнопок ---
bool isModePressed = false;
unsigned long lastModeReleaseTime = 0;
const unsigned long DEBOUNCE_TIME = 200;

// --- Стейт-машина 8-секундного протокола Красной кнопки (Reset) ---
enum ResetState { STATE_NORMAL, STATE_COUNTDOWN, STATE_ABORTED };
ResetState currentResetState = STATE_NORMAL;
unsigned long resetStartTime = 0;
int lastSecondsRemaining = -1;
unsigned long lastLedToggleTime = 0;
bool currentLedState = false;

// --- Логика режима сна ---
bool isSleeping = false;
bool screenToldToSleep = false;
unsigned long sleepTransitionTimer = 0;
unsigned long lastActivityTime = 0;
const unsigned long SLEEP_TIMEOUT = 60000; //300000 - это 5 минут

// --- Состояния экрана ---
int displayMode = 0;
unsigned long lastBlinkTime = 0;
bool blinkState = true;
unsigned long lastDisplayUpdateTime = 0;
const unsigned long DISPLAY_UPDATE_INTERVAL = 250;

LiquidCrystal_I2C lcd(0x27, 16, 2);

// --- Кастомные символы ---
byte customChars [8][8] = {
  //  шкала% и прогресс-бар
  {B11111, B10000, B10000, B10000, B10000, B10000, B10000, B11111}, //0 Левый пустой край [
  {B11111, B00001, B00001, B00001, B00001, B00001, B00001, B11111}, //1 Правый пустой край ]
  {B11111, B00000, B00000, B00000, B00000, B00000, B00000, B11111}, //2 Пустое тело =
  {B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111}, //3 Заполненный блок #
  //иконки для графики в тексте
  {B00100, B01110, B11111, B00000, B00000, B11111, B01110, B00100}, //4 стрелки up/down
  {B00100, B01110, B11111, B00100, B00100, B00100, B00100, B00000}, //5 стрелка вверх
  {B00100, B00100, B00100, B00100, B11111, B01110, B00100, B00000}, //6 стрелка вниз
  {B00000, B00001, B00011, B10110, B11100, B01000, B00000, B00000}  //7 галочка
};

void flowPulseISR() {
  pulseCount++;
  flowPulsesSec++;
  lastPulseTime = millis();
  isFlowing = true;
}

void setup() {
  // === ИНИЦИАЛИЗАЦИЯ МОНИТОРА ПОРТА ===
  Serial.begin(9600);
  Serial.println(F("--- AQUA MONITOR 3.8 SYSTEM START ---"));

  pinMode(FLOW_SENSOR_PIN, INPUT_PULLUP);
  pinMode(BUTTON_MODE_PIN, INPUT_PULLUP);
  pinMode(BUTTON_RESET_PIN, INPUT_PULLUP);
  pinMode(BUTTON_UP_PIN, INPUT_PULLUP);
  pinMode(BUTTON_DOWN_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  // Инициализируем дисплей
  lcd.init();
  lcd.backlight();
  // Загружаем ВСЕ 8 кастомных символов в CGRAM дисплея LCD 1602 одним махом
  for (int i = 0; i < 8; i++) {
    lcd.createChar(i, customChars[i]);
  }

  //Приветствие
  lcd.setCursor(0, 0); lcd.print("RD&P Laboratory ");
  lcd.setCursor(0, 1); lcd.print(" with Gemini O_o");
  delay(1500);
  lcd.clear();
  //эмитация "загрузки" устройства
  lcd.setCursor(0, 0); lcd.print("AQUA MONITOR 3.8");
  lcd.setCursor(0, 1);
  for (int i = 0; i < 16; i++) {
    lcd.write(3);
    delay(30);
  }
  delay(1000);
  lcd.clear();

  if (EEPROM.read(EEPROM_ADDR_INIT) != EEPROM_INIT_KEY) {
    EEPROM.write(EEPROM_ADDR_INIT, EEPROM_INIT_KEY);
    if (!TEST_MODE) {
      EEPROM.put(EEPROM_ADDR_LITERS, 0.0f);
      EEPROM.put(EEPROM_ADDR_TOTAL, 0.0f);
      EEPROM.put(EEPROM_ADDR_CALIB, 0.04500f);  // Базовая калибровка датчика при первом запуске 450.0f, для теста 0.0450f
      EEPROM.put(EEPROM_ADDR_RESOURCE, 10000.0f);
      EEPROM.put(EEPROM_ADDR_DAYS, 0);

      EEPROM.put(EEPROM_ADDR_TOTAL_DAYS, 0); // <--- Пишем при первом запуске

      EEPROM.put(EEPROM_ADDR_PERIODS, 0);
    }
    litersPassed = 0.0;
    totalLitersPassed = 0.0;
    calibrationFactor = 0.04500;  //450.0 - Калибровка датчика по умолчанию, для теста 0.0450
    totalResourceLiters = 10000.0; // ресурс блока фильтров по умолчанию
    daysPassed = 0;

    totalDaysPassed = 0; // <--- Обнуляем в RAM

    periodsAccumulated = 0;
  } else {
    if (!TEST_MODE) {
      EEPROM.get(EEPROM_ADDR_LITERS, litersPassed);
      EEPROM.get(EEPROM_ADDR_TOTAL, totalLitersPassed);
      EEPROM.get(EEPROM_ADDR_CALIB, calibrationFactor);
      EEPROM.get(EEPROM_ADDR_RESOURCE, totalResourceLiters);
      EEPROM.get(EEPROM_ADDR_DAYS, daysPassed);

      EEPROM.get(EEPROM_ADDR_TOTAL_DAYS, totalDaysPassed); // <--- Читаем из памяти

      EEPROM.get(EEPROM_ADDR_PERIODS, periodsAccumulated);
    }

    if (isnan(calibrationFactor) || calibrationFactor < 100.0 || calibrationFactor > 1000.0) calibrationFactor = 450.0;
    if (isnan(totalResourceLiters) || totalResourceLiters < 1000.0 || totalResourceLiters > 99000.0) totalResourceLiters = 10000.0;
    if (daysPassed < 0 || daysPassed > 3000) daysPassed = 0;

    if (totalDaysPassed < 0 || totalDaysPassed > 9999) totalDaysPassed = 0; // <--- Защита глобальных дней

    if (periodsAccumulated < 0 || periodsAccumulated >= 6) periodsAccumulated = 0;

    Serial.print(F("Loaded Unit Liters: ")); Serial.println(litersPassed, 3);
    Serial.print(F("Loaded Total Liters: ")); Serial.println(totalLitersPassed, 3);
    Serial.print(F("Loaded Calib Factor: ")); Serial.println(calibrationFactor);
    Serial.print(F("Loaded Resource: ")); Serial.println(totalResourceLiters);
    Serial.print(F("Loaded Days Passed: ")); Serial.println(daysPassed);
    Serial.print(F("Loaded Total Days: ")); Serial.println(totalDaysPassed);
  }

  currentResource = totalResourceLiters - litersPassed;
  attachInterrupt(digitalPinToInterrupt(FLOW_SENSOR_PIN), flowPulseISR, FALLING);

  unsigned long startupTime = millis();
  lastFlowMillis = startupTime;
  lastPeriodMillis = startupTime;
  lastActivityTime = startupTime;
  Serial.println(F("System Ready."));
}

void loop() {
  unsigned long currentTime = millis();   // Единая метка времени для всего цикла loop!

  if (currentTime - lastPeriodMillis >= SAVE_PERIOD) {
    lastPeriodMillis = currentTime;
    if (currentResetState == STATE_NORMAL) {
      periodsAccumulated++;
      if (periodsAccumulated >= 6) {
        periodsAccumulated = 0;
        daysPassed++;
        totalDaysPassed++; // <--- Плюсуем глобальный счетчик

        if (!TEST_MODE) {
          EEPROM.put(EEPROM_ADDR_DAYS, daysPassed);
          EEPROM.put(EEPROM_ADDR_TOTAL_DAYS, totalDaysPassed); // <--- Сохраняем глобальный
        }

      }
      if (!TEST_MODE) EEPROM.put(EEPROM_ADDR_PERIODS, periodsAccumulated);
    }
  }

  if (currentTime - lastFlowMillis >= 1000) {
    noInterrupts();
    unsigned long pulsesLastSec = flowPulsesSec;
    flowPulsesSec = 0;
    interrupts();

    float targetFlowRate = ((float)pulsesLastSec * 60.0) / calibrationFactor;
    currentFlowRate = (currentFlowRate * 0.4) + (targetFlowRate * 0.6);

    if (pulsesLastSec == 0 && currentTime - lastPulseTime > 1200) {
      currentFlowRate = 0.0;
    }
    lastFlowMillis = currentTime;
  }

  if (isFlowing) {
    if (currentResetState == STATE_NORMAL) {
      noInterrupts();
      unsigned long pulses = pulseCount;
      pulseCount = 0;
      isFlowing = false;
      interrupts();

      if (pulses > 0) {
        float delta = (float)pulses / calibrationFactor;
        litersPassed += delta;
        totalLitersPassed += delta;
        currentResource = totalResourceLiters - litersPassed;
        needEepromWrite = true;
        lastEepromWriteTime = currentTime;
        lastActivityTime = currentTime;
        digitalWrite(LED_PIN, HIGH);
      }
    }
  }

  if (currentResetState == STATE_NORMAL && currentTime - lastPulseTime > 200) {
    digitalWrite(LED_PIN, LOW);
  }

  // Фоновое сохранение литров, запись in EEPROM через 60 секунд после остановки потока
  if (needEepromWrite && (currentTime - lastEepromWriteTime > 60000)) {
    if (!TEST_MODE) {
      EEPROM.put(EEPROM_ADDR_LITERS, litersPassed);
      EEPROM.put(EEPROM_ADDR_TOTAL, totalLitersPassed);
    }
    needEepromWrite = false;
    Serial.println(F("[EEPROM] Data saved successfully."));
  }

  bool modeState = (digitalRead(BUTTON_MODE_PIN) == LOW);
  bool upState = (digitalRead(BUTTON_UP_PIN) == LOW);
  bool downState = (digitalRead(BUTTON_DOWN_PIN) == LOW);

  // --- ЛИСТАНИЕ МЕНЮ ---
  if (modeState && !isModePressed) {
    if (currentTime - lastModeReleaseTime > DEBOUNCE_TIME) {
      isModePressed = true;
      lastActivityTime = currentTime;

      if (isSleeping || screenToldToSleep) {
        isSleeping = false;
        screenToldToSleep = false;
        lcd.backlight();
        lcd.clear();
        Serial.println(F("[SYSTEM] Woke up from sleep."));
      } else {
        if (currentResetState == STATE_NORMAL) {
          if (displayMode == 6) { // Выход из настройки сенсора без сохранения
            displayMode = 5;
            if (!TEST_MODE) EEPROM.get(EEPROM_ADDR_CALIB, calibrationFactor);
          } else if (displayMode == 8) { // Выход из настройки ресурса без сохранения
            displayMode = 7;
            if (!TEST_MODE) EEPROM.get(EEPROM_ADDR_RESOURCE, totalResourceLiters);
          } else {
            // Перепрыгиваем активные режимы настройки (6 и 8) при простом листании
            if (displayMode == 5) displayMode = 7;
            else if (displayMode == 7) displayMode = 0;
            else displayMode++;
          }
          lcd.clear();
          Serial.print(F("[UI] Display mode changed to: ")); Serial.println(displayMode);
        }
      }
    }
  } else if (!modeState && isModePressed) {
    isModePressed = false;
    lastModeReleaseTime = currentTime;
    lastActivityTime = currentTime;
  }

  // ВХОД В НАСТРОЙКИ (UP + DOWN) на экране "5"
  if (currentResetState == STATE_NORMAL && !isSleeping) {
    if (displayMode == 5 && upState) { // && downState) { // сейчас стоит только кнопка Up для теста на ПК
      displayMode = 6;
      lastActivityTime = currentTime;
      lcd.clear();
      delay(500);
    }
    // ВХОД В НАСТРОЙКИ (UP + DOWN) на экране "7"
    if (displayMode == 7 && upState) { // && downState) { // сейчас стоит только кнопка Up для теста на ПК
      displayMode = 8;
      lastActivityTime = currentTime;
      lcd.clear();
      delay(500);
    }
  }

  // --- ЛОГИКА НАСТРОЙКИ КАЛИБРОВКИ (МЕНЮ 6) ---
  if (displayMode == 6 && currentResetState == STATE_NORMAL && !isSleeping) {
    if (upState && !downState && calibrationFactor < 600.0) {
      calibrationFactor += 5.0;
      lastActivityTime = currentTime;
      delay(200);
    }
    if (downState && !upState && calibrationFactor > 300.0) {
      calibrationFactor -= 5.0;
      lastActivityTime = currentTime;
      delay(200);
    }
  }

  // --- ЛОГИКА НАСТРОЙКИ РЕСУРСА (МЕНЮ 8) ---
  if (displayMode == 8 && currentResetState == STATE_NORMAL && !isSleeping) {
    if (upState && !downState && totalResourceLiters < 99000.0) {
      totalResourceLiters += 100.0;
      lastActivityTime = currentTime;
      delay(200);
    }
    if (downState && !upState && totalResourceLiters > 1000.0) {
      totalResourceLiters -= 100.0;
      lastActivityTime = currentTime;
      delay(200);
    }
  }

  // --- ПРОТОКОЛ КРАСНОЙ КНОПКИ RESET ---
  bool currentPhysicalResetState = digitalRead(BUTTON_RESET_PIN);
  bool resetState = (currentPhysicalResetState == LOW);

  if (!isSleeping && !screenToldToSleep) {
    if (resetState) lastActivityTime = currentTime;

    if (currentResetState == STATE_NORMAL) {
      // Добавили displayMode == 8 как триггер для сохранения
      if (resetState && (displayMode == 3 || displayMode == 4 || displayMode == 6 || displayMode == 8)) {
        currentResetState = STATE_COUNTDOWN;
        resetStartTime = currentTime;
        lastSecondsRemaining = -1;
        detachInterrupt(digitalPinToInterrupt(FLOW_SENSOR_PIN));
        digitalWrite(LED_PIN, LOW);
        lcd.clear();
        Serial.println(F("[PROTOCOL] Countdown Started! Holding RESET button..."));
      }
    }
    else if (currentResetState == STATE_COUNTDOWN) {
      if (!resetState) {
        currentResetState = STATE_ABORTED;
        resetStartTime = currentTime;
        digitalWrite(LED_PIN, LOW);
        lcd.clear();
        lcd.setCursor(0, 0); lcd.print("Process ABORTED!");

        if (displayMode == 6) {
          lcd.setCursor(0, 1); lcd.print("Settings Reverted");
          if (!TEST_MODE) EEPROM.get(EEPROM_ADDR_CALIB, calibrationFactor);
        } else if (displayMode == 8) {
          lcd.setCursor(0, 1); lcd.print("Settings Reverted");
          if (!TEST_MODE) EEPROM.get(EEPROM_ADDR_RESOURCE, totalResourceLiters);
        } else {
          lcd.setCursor(0, 1); lcd.print("Data NOT Deleted");
        }
        Serial.println(F("[PROTOCOL] ABORTED by user! Data is safe."));
      }
      else {
        unsigned long elapsed = currentTime - resetStartTime;
        int secondsRemaining = 8 - (elapsed / 1000);
        if (secondsRemaining < 0) secondsRemaining = 0;

        if (secondsRemaining != lastSecondsRemaining) {
          lastSecondsRemaining = secondsRemaining;
          lcd.setCursor(0, 0);

          if (displayMode == 3) lcd.print("INSTALL NEW Unit? ");
          else if (displayMode == 4) lcd.print("RESET ALL DATA ? ");
          else if (displayMode == 6) lcd.print("SAVE NEW Value ? ");
          else if (displayMode == 8) lcd.print("SAVE NEW Res. ?  ");

          lcd.setCursor(0, 1);  lcd.print("  Passed "); lcd.print(secondsRemaining); lcd.print(" sec.  ");
          Serial.print(F("[PROTOCOL] Time left: ")); Serial.print(secondsRemaining); Serial.println(F("s..."));
        }

        unsigned long toggleInterval = (secondsRemaining * 50) + 30;
        if (currentTime - lastLedToggleTime > toggleInterval) {
          currentLedState = !currentLedState;
          digitalWrite(LED_PIN, currentLedState ? HIGH : LOW);
          lastLedToggleTime = currentTime;
        }

        if (elapsed >= 8000) {
          Serial.println(F("[PROTOCOL] 8 SECONDS REACHED. EXECUTING..."));
          digitalWrite(LED_PIN, HIGH);
          lcd.clear();

          if (displayMode == 6 || displayMode == 8) lcd.print("SAVING A VALUE..  ");
          else lcd.print("ERASING A DATA.. ");

          lcd.setCursor(0, 1);
          for (int i = 0; i < 16; i++) {
            lcd.write(3);
            delay(30);
          }
          delay(1000);
          lcd.clear();

          if (displayMode == 3) {
            litersPassed = 0.0;
            daysPassed = 0;
            periodsAccumulated = 0;
            currentResource = totalResourceLiters;
            if (!TEST_MODE) {
              EEPROM.put(EEPROM_ADDR_LITERS, litersPassed);
              EEPROM.put(EEPROM_ADDR_DAYS, daysPassed);
              EEPROM.put(EEPROM_ADDR_PERIODS, periodsAccumulated);
              Serial.println(F("[EEPROM] Unit Data Updated."));
            }
          }
          else if (displayMode == 4) {
            litersPassed = 0.0;
            totalLitersPassed = 0.0;
            daysPassed = 0;

            totalDaysPassed = 0; // <--- А вот тут сбрасываем всё

            periodsAccumulated = 0;
            currentResource = totalResourceLiters;
            if (!TEST_MODE) {
              EEPROM.put(EEPROM_ADDR_LITERS, litersPassed);
              EEPROM.put(EEPROM_ADDR_TOTAL, totalLitersPassed);
              EEPROM.put(EEPROM_ADDR_DAYS, daysPassed);

              EEPROM.put(EEPROM_ADDR_TOTAL_DAYS, totalDaysPassed); // <--- Очищаем в памяти

              EEPROM.put(EEPROM_ADDR_PERIODS, periodsAccumulated);
              Serial.println(F("[EEPROM] Total System FULL ERASE completed."));
            }
          }
          else if (displayMode == 6) {
            if (!TEST_MODE) {
              EEPROM.put(EEPROM_ADDR_CALIB, calibrationFactor);
              Serial.println(F("[EEPROM] Calibration Factor Saved."));
            }
          }
          else if (displayMode == 8) {
            currentResource = totalResourceLiters - litersPassed; // Пересчитываем остаток
            if (!TEST_MODE) {
              EEPROM.put(EEPROM_ADDR_RESOURCE, totalResourceLiters);
              Serial.println(F("[EEPROM] Resource Target Saved."));
            }
          }

          needEepromWrite = false;
          pulseCount = 0;
          currentFlowRate = 0.0;
          displayMode = 0;
          digitalWrite(LED_PIN, LOW);
          lcd.clear();

          currentResetState = STATE_NORMAL;
          attachInterrupt(digitalPinToInterrupt(FLOW_SENSOR_PIN), flowPulseISR, FALLING);
          lastActivityTime = currentTime;
          Serial.println(F("[SYSTEM] Returned to normal operation."));
        }
      }
    }
    else if (currentResetState == STATE_ABORTED) {
      lastActivityTime = currentTime;
      if (currentTime - resetStartTime > 1500) {
        lcd.clear();
        currentResetState = STATE_NORMAL;
        attachInterrupt(digitalPinToInterrupt(FLOW_SENSOR_PIN), flowPulseISR, FALLING);
        lastActivityTime = currentTime;
      }
    }
  }

  // --- УМНЫЙ СОН ---
  if (currentResetState == STATE_NORMAL) {
    if (!isSleeping && !screenToldToSleep && (currentTime - lastActivityTime >= SLEEP_TIMEOUT)) {
      screenToldToSleep = true;
      sleepTransitionTimer = currentTime;
      lcd.backlight(); lcd.clear();
      lcd.setCursor(0, 0); lcd.print("[O_o] (z-z-z)   ");
      lcd.setCursor(5, 1); lcd.print("sleeping...     ");
      Serial.println(F("[SYSTEM] Preparing to sleep..."));
    }
    if (!isSleeping && screenToldToSleep && (currentTime - sleepTransitionTimer >= 2000)) {
      isSleeping = true;
      screenToldToSleep = false;
      lcd.noBacklight(); lcd.clear();
      Serial.println(F("[SYSTEM] Device is now sleeping."));
    }
  }

  if (currentTime - lastBlinkTime > 500) {
    blinkState = !blinkState;
    lastBlinkTime = currentTime;
  }

  if (currentResetState == STATE_NORMAL && !isSleeping && !screenToldToSleep) {
    if (currentTime - lastDisplayUpdateTime >= DISPLAY_UPDATE_INTERVAL) {
      drawDisplay();
      lastDisplayUpdateTime = currentTime;
    }
  }
}

void drawDisplay() {
  float percent = (currentResource / totalResourceLiters) * 100.0;
  bool isExpiredResource = (currentResource <= 0);

  if (displayMode == 0) {
    lcd.setCursor(0, 0); lcd.print("Flow: ");
    if (currentFlowRate <= 0.05) {
      lcd.print("[X] CLOSED  ");
    }
    else if (currentFlowRate < 1.800) {
      lcd.print("["); lcd.write(5); lcd.print("] Raise! ");
    }
    else if (currentFlowRate > 2.200) {
      lcd.print("["); lcd.write(6); lcd.print("] Lower! ");
    }
    else {
      lcd.print("["); lcd.write(7); lcd.print("] NORMAL  ");
    }

    lcd.setCursor(0, 1);
    if (currentFlowRate < 10.0) {
      lcd.print("0");
    }
    lcd.print(currentFlowRate, 3); lcd.print(" L/min    ");
  }

  else if (displayMode == 1) {
    // --- ПЕРВАЯ СТРОКА: USAG ###### xxx% (Ровно 16 символов) ---
    lcd.setCursor(0, 0);
    lcd.print("USAGE ");

    if (isExpiredResource && !blinkState) {
      lcd.print("     ");
    }
    else {
      if (isExpiredResource) {
        lcd.write(0); lcd.write(2); lcd.write(2); lcd.write(2); lcd.write(1);
        //lcd.write(0); lcd.write(2); lcd.write(2); lcd.write(2); lcd.write(2); lcd.write(1);
      }
      else {
        int activeBlocks = (int)((percent / 100.0) * 5.0 + 0.5);
        activeBlocks = constrain(activeBlocks, 1, 5);
        for (int i = 0; i < 5; i++) {
          if (i < activeBlocks) lcd.write(3);
          else {
            if (i == 0) lcd.write(0);
            else if (i == 4) lcd.write(1);
            else lcd.write(2);
          }
        }
      }
    }

    lcd.print(" ");

    int p = (int)percent;
    if (p <= 0 && !blinkState) {
      lcd.print("    ");
    } else {
      if (p <= 0) p = 0;
      if (p >= 100) {
        lcd.print(p); lcd.print("%");
      }
      else if (p >= 10) {
        lcd.print("0"); lcd.print(p); lcd.print("%");
      }
      else {
        lcd.print("00"); lcd.print(p); lcd.print("%");
      }
    }

    // --- ВТОРАЯ СТРОКА: xxxxx L/Days xxx (Ровно 16 символов) ---
    lcd.setCursor(0, 1);
    float displayLiters = totalResourceLiters - litersPassed;

    int litInt = (int)displayLiters;
    if (litInt < 0) litInt = 0;
    if (litInt > 99999) litInt = 99999;

    if (displayLiters <= 0.0 && !blinkState) {
      lcd.print("     ");
    }
    else {
      if (litInt < 10000) lcd.print("0");
      if (litInt < 1000)  lcd.print("0");
      if (litInt < 100)   lcd.print("0");
      if (litInt < 10)    lcd.print("0");
      lcd.print(litInt);
    }

    lcd.print(" L/Days ");

    int daysLeft = 366 - daysPassed;

    if (daysLeft <= 0 && !blinkState) {
      lcd.print("   ");
    }
    else {
      if (daysLeft < 0) daysLeft = 0;
      if (daysLeft > 999) daysLeft = 999;

      if (daysLeft < 100) lcd.print("0");
      if (daysLeft < 10)  lcd.print("0");
      lcd.print(daysLeft);
    }
  }

  else if (displayMode == 2) {
    // --- ПЕРВАЯ СТРОКА: Total: xxxx Days (Ровно 16 символов) ---
    lcd.setCursor(0, 0);
    lcd.print("Total: ");

    int d = totalDaysPassed; // <--- ИСПОЛЬЗУЕМ НОВУЮ ГЛОБАЛЬНУЮ ПЕРЕМЕННУЮ
    if (d < 0) d = 0;
    if (d > 9999) d = 9999;

    if (d < 1000) lcd.print("0");
    if (d < 100)  lcd.print("0");
    if (d < 10)   lcd.print("0");
    lcd.print(d);

    lcd.print(" Days");

    // --- ВТОРАЯ СТРОКА: xxxxxxx.x Litres (Ровно 16 символов) ---
    lcd.setCursor(0, 1);
    float displayTotal = totalLitersPassed;
    if (displayTotal < 0.0) displayTotal = 0.0;
    if (displayTotal > 9999999.9) displayTotal = 9999999.9;

    if (displayTotal < 1000000.0) lcd.print("0");
    if (displayTotal < 100000.0)  lcd.print("0");
    if (displayTotal < 10000.0)   lcd.print("0");
    if (displayTotal < 1000.0)    lcd.print("0");
    if (displayTotal < 100.0)     lcd.print("0");
    if (displayTotal < 10.0)      lcd.print("0");

    lcd.print(displayTotal, 1);

    lcd.print(" Litres");
  }

  else if (displayMode == 3) {
    lcd.setCursor(0, 0); lcd.print("(i) Unit UPDATE:");
    lcd.setCursor(0, 1); lcd.print("HOLD RED Button!");
  }
  else if (displayMode == 4) {
    lcd.setCursor(0, 0); lcd.print("[!] TOTAL RESET:");
    lcd.setCursor(0, 1); lcd.print("HOLD RED Button!");
  }
  else if (displayMode == 5) {
    lcd.setCursor(0, 0); lcd.print("<*> SET FlowSens");
    lcd.setCursor(0, 1); lcd.print("Up+Down >> BEGIN");
  }
  else if (displayMode == 6) {
    lcd.setCursor(0, 0);
    lcd.print("Curr.Value "); lcd.print((int)calibrationFactor);
    lcd.print(" "); lcd.write(4); lcd.print("  ");
    lcd.setCursor(0, 1);
    lcd.print("HOLD > Save&Exit");
  }
  // НОВЫЙ ЭКРАН - Вход в настройку ресурса
  else if (displayMode == 7) {
    lcd.setCursor(0, 0); lcd.print("<*> SET Resource");
    lcd.setCursor(0, 1); lcd.print("Up+Down >> BEGIN");
  }
  // НОВЫЙ ЭКРАН - Редактирование ресурса
  else if (displayMode == 8) {
    lcd.setCursor(0, 0);
    lcd.print("Unit: ");

    int rInt = (int)totalResourceLiters;
    if (rInt < 10000) lcd.print("0"); // Добиваем 0 для красоты верстки
    lcd.print(rInt);

    lcd.print(" L. "); lcd.write(4);

    lcd.setCursor(0, 1);
    lcd.print("HOLD > Save&Exit");
  }
}