#include <Wire.h>
#include <RTClib.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
#include <string.h>
#include <EEPROM.h>

// Initialize the RTC and LCD
RTC_DS3231 rtc;
LiquidCrystal_I2C lcd(0x27, 20, 4); // Adjust the I2C address if necessary

// Keypad configuration
const byte ROWS = 4; // Four rows
const byte COLS = 4; // Four columns

// Define the symbols on the buttons of the keypad
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

// Connect keypad ROW0, ROW1, ROW2, ROW3 to these Arduino pins
byte rowPins[ROWS] = {9, 8, 7, 6};

// Connect keypad COL0, COL1, COL2, COL3 to these Arduino pins
byte colPins[COLS] = {5, 4, 3, 2};

// Create Keypad object
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// Define digital pins for pump and solenoid valve
const int pumpPin = 51;
const int valvePin = 53;
const int tank1out = 49;
const int tank2out = 47;
const int tank1in = 45;
const int tank2in = 43;
const int tank1LowSensor = 50;
const int tank1HighSensor = 46;
const int tank2LowSensor = 48;
const int tank2HighSensor = 44;
const int tank1fill = 41;
const int tank2fill = 39;
//RELAY NAMES
/*
Main Valve - 53
Pump - 51
tank1out - 49
tank2out - 47
tank1in - 45
tank2in - 43
*/


// Define analog pin for soil moisture sensor
const int moisturePin = A0;

// Timer Mode variables
int timer1StartHour = 0;
int timer1StartMinute = 0;
int timer1Duration = 0;
int timer2StartHour = 0;
int timer2StartMinute = 0;
int timer2Duration = 0;

// Saver Mode variable
int moistureThreshold = 0;
int IrrigationTime = 0;

// Anemometer
const int anemometerPin = A1;
int windSpeedThreshold = 5; // in m/s

//Rain Sensor
const int rainPin = 52;
int rainTimer = 5;

// Tank Refill Times
int tank1RefillHour = 0;
int tank1RefillMinute = 0;
int tank2RefillHour = 0;
int tank2RefillMinute = 0;

// Current mode selection
int mode = 0;
enum {MAIN_MENU, MODE, TIMER_MODE, SAVER_MODE, SETUP, CALIBRATE, REFILL_SETUP} state = MAIN_MENU;

// Water source selection
enum {TAP, TANK1, TANK2} waterSource = TAP;

// Function prototypes
void displayMainMenu();
void loadSettingsFromEEPROM();
void selectMode();
void ModeSetup();
void calibrateSensors();
void refillSetup();
void executeTimerMode();
void executeSaverMode();
void handleKeypadInput();
int getIntInput(int col, int row);
float readWindSpeed();
void aborted();
int Anemometer();
int raining();
bool checkTank(int tankNumber);
int fillTank(int tankNumber);
//void checkSource(int tankNumber);

//EEPROM Addresses
//TimerMode
int timer1StartHourEEPROM = 10;
int timer1StartMinuteEEPROM = 12;
int timer1DurationEEPROM = 14;
int timer2StartHourEEPROM = 16;
int timer2StartMinuteEEPROM = 18;
int timer2DurationEEPROM = 20;
int waterSourceEEPROM = 22;
//SaverMode
int IrrigationTimeEEPROM = 24;
//Calibration
int windSpeedThresholdEEPROM = 26;
int moistureThresholdEEPROM = 28;
//Refill
int tank1RefillHourEEPROM = 30;
int tank1RefillMinuteEEPROM = 32;
int tank2RefillHourEEPROM = 34;
int tank2RefillMinuteEEPROM = 36;

/*int address = 0;
float val;*/

void setup() {
  // Initialize serial communication
  Serial.begin(9600);

  loadSettingsFromEEPROM();

  // Initialize the LCD and RTC
  lcd.init();
  lcd.backlight();

  // Initialize pins
  pinMode(pumpPin, OUTPUT);
  pinMode(valvePin, OUTPUT);
  digitalWrite(pumpPin, LOW);
  digitalWrite(valvePin, LOW);
  pinMode(tank1out, OUTPUT);
  pinMode(tank2out, OUTPUT);
  pinMode(tank1in, OUTPUT);
  pinMode(tank2in, OUTPUT);
  pinMode(tank1LowSensor, INPUT);
  pinMode(tank1HighSensor, INPUT);
  pinMode(tank2LowSensor, INPUT);
  pinMode(tank2HighSensor, INPUT);
  pinMode(tank1fill, OUTPUT);
  pinMode(tank2fill, OUTPUT);

  // Check if the RTC is connected
  if (!rtc.begin()) {
    lcd.print("Couldn't find RTC");
    while (1);
  }
  /*float num = 5.0;
  address += sizeof(float);
  EEPROM.put(address, num);*/

  // Initial display
  displayMainMenu();
}

void loop() {
  //val = EEPROM.read(address);
  //Serial.print(val);
  handleKeypadInput();

  DateTime now = rtc.now();
  if (now.hour() == tank1RefillHour && now.minute() == tank1RefillMinute) {
    //Serial.print("Filling tank 1\n");
    fillTank(1);
    //Serial.print("Done filling tank 1\n");
  }
  if (now.hour() == tank2RefillHour && now.minute() == tank2RefillMinute) {
    //Serial.print("Filling Tank 2\n");
    fillTank(2);
    //Serial.print("Done filling tank 2\n");
  }

  switch (state) {
    case MAIN_MENU:
      // Do nothing, waiting for user input
      break;
    case MODE:
      selectMode();
      break;
    case TIMER_MODE:
      executeTimerMode();
      break;
    case SAVER_MODE:
      executeSaverMode();
      break;
    case SETUP:
      ModeSetup();
      break;
    case CALIBRATE:
      calibrateSensors();
      break;
    case REFILL_SETUP:
      refillSetup();
      break;
  }
}

void displayMainMenu() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("1: Select Mode");
  lcd.setCursor(0, 1);
  lcd.print("2: Mode Setup");
  lcd.setCursor(0,2);
  lcd.print("3. Calibrate Sensors");
  lcd.setCursor(0, 3);
  lcd.print("4: Set Tank Refill");
}

void loadSettingsFromEEPROM() {
  EEPROM.get(timer1StartHourEEPROM, timer1StartHour);
  EEPROM.get(timer1StartMinuteEEPROM, timer1StartMinute);
  EEPROM.get(timer1DurationEEPROM, timer1Duration);
  EEPROM.get(timer2StartHourEEPROM, timer2StartHour);
  EEPROM.get(timer2StartMinuteEEPROM, timer2StartMinute);
  EEPROM.get(timer2DurationEEPROM, timer2Duration);
  EEPROM.get(waterSourceEEPROM, waterSource);
  EEPROM.get(IrrigationTimeEEPROM, IrrigationTime);
  EEPROM.get(windSpeedThresholdEEPROM, windSpeedThreshold);
  EEPROM.get(moistureThresholdEEPROM, moistureThreshold);
  EEPROM.get(tank1RefillHourEEPROM, tank1RefillHour);
  EEPROM.get(tank1RefillMinuteEEPROM, tank1RefillMinute);
  EEPROM.get(tank2RefillHourEEPROM, tank2RefillHour);
  EEPROM.get(tank2RefillMinuteEEPROM, tank2RefillMinute);

  //Troubleshooting
  Serial.println("Settings loaded from EEPROM:");
  Serial.print("timer1StartHour: "); Serial.println(timer1StartHour);
  Serial.print("timer1StartMinute: "); Serial.println(timer1StartMinute);
  Serial.print("timer1Duration: "); Serial.println(timer1Duration);
  Serial.print("timer2StartHour: "); Serial.println(timer2StartHour);
  Serial.print("timer2StartMinute: "); Serial.println(timer2StartMinute);
  Serial.print("timer2Duration: "); Serial.println(timer2Duration);
  Serial.print("waterSource: "); Serial.println(waterSource);
  Serial.print("IrrigationTime: "); Serial.println(IrrigationTime);
  Serial.print("windSpeedThreshold: "); Serial.println(windSpeedThreshold);
  Serial.print("moistureThreshold: "); Serial.println(moistureThreshold);
  Serial.print("tank1RefillHour: "); Serial.println(tank1RefillHour);
  Serial.print("tank1RefillMinute: "); Serial.println(tank1RefillMinute);
  Serial.print("tank2RefillHour: "); Serial.println(tank2RefillHour);
  Serial.print("tank2RefillMinute: "); Serial.println(tank2RefillMinute);
}

void selectMode() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("1: Timer Mode");
  lcd.setCursor(0, 1);
  lcd.print("2: Saver Mode");

  char key = keypad.getKey();
  while(key == NO_KEY){
    key = keypad.getKey();
  }

  switch(key){
    case '1':
      state = TIMER_MODE;
      executeTimerMode();
      break;
    case '2':
      state = SAVER_MODE;
      executeSaverMode();
      break;
    case 'D':
      state = MAIN_MENU;
      displayMainMenu();
      break;
    default:
      break;
 }
}


void ModeSetup() {
  int input;
  int source;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("TIMER MODE SETUP");
  lcd.setCursor(0, 1);
  lcd.print("1st cycle start");
  lcd.setCursor(0, 2);
  lcd.print("Hour (0-23):");
  // User enters start hour for the first cycle
  //timer1StartHour = getIntInput(0, 2);
  input = getIntInput(0, 3);
  if(input == 9999){
    return;
  }else{
    timer1StartHour = input;
    EEPROM.put(timer1StartHourEEPROM, timer1StartHour);
  }
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("TIMER MODE SETUP");
  lcd.setCursor(0, 1);
  lcd.print("1st cycle start");
  lcd.setCursor(0, 2);
  lcd.print("Minute (0-59):");
  // User enters start minute for the first cycle
  //timer1StartMinute = getIntInput(0, 2);
  input = getIntInput(0, 3);
  if(input == 9999){
    return;
  }else{
    timer1StartMinute = input;
    EEPROM.put(timer1StartMinuteEEPROM, timer1StartMinute);
  }
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("TIMER MODE SETUP");
  lcd.setCursor(0, 1);
  lcd.print("1st cycle duration");
  lcd.setCursor(0, 2);
  lcd.print("Duration (min):");
  // User enters duration for the first cycle
  input = getIntInput(0, 3);
  if(input == 9999){
    return;
  }else{
    timer1Duration = input;
    EEPROM.put(timer1DurationEEPROM, timer1Duration);
  }
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("TIMER MODE SETUP");
  lcd.setCursor(0, 1);
  lcd.print("2nd cycle start");
  lcd.setCursor(0, 2);
  lcd.print("Hour (0-23):");
  // User enters start hour for the second cycle
  input = getIntInput(0, 3);
  if(input == 9999){
    return;
  }else{
    timer2StartHour = input;
    EEPROM.put(timer2StartHourEEPROM, timer2StartHour);
  }  
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("TIMER MODE SETUP");
  lcd.setCursor(0, 1);
  lcd.print("2nd cycle start");
  lcd.setCursor(0, 2);
  lcd.print("Minute (0-59):");
  // User enters start minute for the second cycle
  input = getIntInput(0, 3);
  if(input == 9999){
    return;
  }else{
    timer2StartMinute = input;
    EEPROM.put(timer2StartMinuteEEPROM, timer2StartMinute);
  }
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("TIMER MODE SETUP");
  lcd.setCursor(0, 1);
  lcd.print("2nd cycle duration");
  lcd.setCursor(0, 2);
  lcd.print("Duration (min):");
  // User enters duration for the second cycle
  input = getIntInput(0, 3);
  if(input == 9999){
    return;
  }else{
    timer2Duration = input;
    EEPROM.put(timer2DurationEEPROM, timer2Duration);
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("SAVER MODE SETUP");
  lcd.setCursor(0, 1);
  lcd.print("Enter Irrigation");
  lcd.setCursor(0, 2);
  lcd.print("duration (0-60)mins:");
  lcd.setCursor(0, 3);
  input = getIntInput(0, 3);
  if(input == 9999){
    return;
  }else{
    IrrigationTime = input;
    EEPROM.put(IrrigationTimeEEPROM, IrrigationTime);
  }
  
  // Select water source
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Select Water Source");
  lcd.setCursor(0, 1);
  lcd.print("1: Tap");
  lcd.setCursor(0, 2);
  lcd.print("2: Tank 1, 3: Tank 2");
  lcd.setCursor(0, 3);
  input = getIntInput(0, 3);
  if(input == 9999){
    return;
  }else{
    source = input;
  }
  
  if (source == 1) waterSource = TAP;
  else if (source == 2) waterSource = TANK1;
  else if (source == 3) waterSource = TANK2;
  EEPROM.put(waterSourceEEPROM, waterSource);

  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print("  Mode Setup Saved  ");
  delay(1000);
  state = MAIN_MENU;
  displayMainMenu();
}

void calibrateSensors(){
  int input;
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Enter Wind Speed");
  lcd.setCursor(0, 1);
  lcd.print("threshold (0-30)m/s:");
  lcd.setCursor(0, 3);
  input = getIntInput(0, 2);
  if(input == 9999){
    return;
  }else{
    windSpeedThreshold = input;
    EEPROM.put(windSpeedThresholdEEPROM, windSpeedThreshold);
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Enter moisture");
  lcd.setCursor(0, 1);
  lcd.print("threshold (0-1024):");
  lcd.setCursor(0, 3);
  input = getIntInput(0, 2);
  if(input == 9999){
    return;
  }else{
    moistureThreshold = input;
    EEPROM.put(moistureThresholdEEPROM, moistureThreshold);
  }
  lcd.clear();

  lcd.setCursor(0, 1);
  lcd.print("   Settings saved   ");
  delay(1000);
  lcd.clear();
  state = MAIN_MENU;
  displayMainMenu();
}

void refillSetup(){
  int input;
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Tank 1 Refill Time");
  lcd.setCursor(0, 1);
  lcd.print("Hour (0-23):");
  input = getIntInput(0, 2);
  if(input == 9999){
    return;
  }else{
    tank1RefillHour = input;
    EEPROM.put(tank1RefillHourEEPROM, tank1RefillHour);
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Tank 1 Refill Time");
  lcd.setCursor(0, 1);
  lcd.print("Minute (0-59):");
  input = getIntInput(0, 2);
  if(input == 9999){
    return;
  }else{
    tank1RefillMinute = input;
    EEPROM.put(tank1RefillMinuteEEPROM, tank1RefillMinute);
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Tank 2 Refill Time");
  lcd.setCursor(0, 1);
  lcd.print("Hour (0-23):");
  input = getIntInput(0, 2);
  if(input == 9999){
    return;
  }else{
    tank2RefillHour = input;
    EEPROM.put(tank2RefillHourEEPROM, tank2RefillHour);
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Tank 2 Refill Time");
  lcd.setCursor(0, 1);
  lcd.print("Minute (0-59):");
  input = getIntInput(0, 2);
  if(input == 9999){
    return;
  }else{
    tank2RefillMinute = input;
    EEPROM.put(tank2RefillMinuteEEPROM, tank2RefillMinute);
  }

  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print("  Tank Refill Times ");
  lcd.setCursor(0, 2);
  lcd.print("       Saved.       ");
  delay(1000);
  state = MAIN_MENU;
  displayMainMenu();
}

void executeTimerMode() {
  DateTime now = rtc.now();
  int currentMinute = now.hour() * 60 + now.minute();
  
  int start1 = timer1StartHour * 60 + timer1StartMinute;
  int end1 = start1 + timer1Duration;
  int start2 = timer2StartHour * 60 + timer2StartMinute;
  int end2 = start2 + timer2Duration;

  if ((currentMinute >= start1 && currentMinute < end1) || 
      (currentMinute >= start2 && currentMinute < end2)) {

    unsigned long startMillis = millis(); // Capture start time
    unsigned long irrigationTimeMillis;
    if(currentMinute >= start1 && currentMinute < end1){
      irrigationTimeMillis = timer1Duration * 60000; // Convert minutes to milliseconds
    }else if(currentMinute >= start2 && currentMinute < end2){
      irrigationTimeMillis = timer2Duration * 60000; // Convert minutes to milliseconds
    }

    //checkSource((waterSource));

    if ((waterSource == TANK1 && !checkTank(1)) || (waterSource == TANK2 && !checkTank(2))) {
      lcd.clear();
      lcd.setCursor(0, 0);
      char abc[10];
      sprintf(abc, "Filling Tank %d.", waterSource);
      lcd.print(abc);
      if(fillTank(waterSource) == 1){
        return 1;
      };
      lcd.clear();
      lcd.print("Tank full");
      delay(1000);
      lcd.clear();
    }

    while (millis() - startMillis < irrigationTimeMillis) {
      if(waterSource == TANK1){
        digitalWrite(tank1out, HIGH);
      }else if(waterSource == TANK2){
        digitalWrite(tank2out, HIGH);
      }else{
        digitalWrite(valvePin, HIGH);
      };

      if(raining() == 1){
        digitalWrite(pumpPin, LOW);
        continue;
      }else{
        digitalWrite(pumpPin, HIGH);
      }

      lcd.setCursor(0, 0);
      lcd.print("Timer Mode ON");
      lcd.setCursor(0, 1);
      lcd.print("Watering: ");
      unsigned long timeLeft = (irrigationTimeMillis - (millis() - startMillis)) / 1000; // Time left in seconds
      lcd.print(timeLeft);
      lcd.print("s left   ");
      lcd.setCursor(0, 3);
      lcd.print("Press * to abort");

      if(Anemometer() == 1){
        return;
      }

      if (keypad.getKey() == '*') { // Abort key
        aborted();
        return;
      }
      if(timeLeft <= 0){
        lcd.setCursor(0, 1);
        lcd.print("Irrigation Complete");
        delay(1000);
        digitalWrite(pumpPin, LOW);
        digitalWrite(tank1out, LOW);
        digitalWrite(tank2out, LOW);
        digitalWrite(valvePin, LOW);
        break;
      }
      
      delay(100); // Update every second
    }
  } else {
    lcd.setCursor(0, 0);
    lcd.print("Timer Mode ON");
    char abc[20];
    sprintf(abc, "Time 1 : %d:%d - %dm", timer1StartHour, timer1StartMinute, timer1Duration);
    lcd.setCursor(0, 1);
    lcd.print(abc);
    sprintf(abc, "Time 2 : %d:%d - %dm", timer2StartHour, timer2StartMinute, timer2Duration);
    lcd.setCursor(0, 2);
    lcd.print(abc);
    lcd.setCursor(0, 3);
    lcd.print("Press * to abort");

    digitalWrite(pumpPin, LOW);
    digitalWrite(tank1out, LOW);
    digitalWrite(tank2out, LOW);
    digitalWrite(valvePin, LOW);
  }

  if (keypad.getKey() == '*') { // Abort key
      aborted();
      return; // Exit the function
  }
}

void executeSaverMode() {
  int moistureLevel = analogRead(moisturePin);

  lcd.setCursor(0, 0);
  lcd.print("Saver Mode ON");
  lcd.setCursor(0, 3);
  lcd.print("Press * to abort");
  if (keypad.getKey() == '*') { // Abort key
    aborted();
    return;
  }

  if (moistureLevel < moistureThreshold) {
    unsigned long startMillis = millis(); // Capture start time
    unsigned long irrigationTimeMillis = IrrigationTime * 60000; // Convert minutes to milliseconds

    //checkSource((waterSource));

    if ((waterSource == TANK1 && !checkTank(1)) || (waterSource == TANK2 && !checkTank(2))) {
      lcd.clear();
      lcd.setCursor(0, 0);
      char abc[10];
      sprintf(abc, "Filling Tank %d.", waterSource);
      lcd.print(abc);
      if(fillTank(waterSource) == 1){
        return;
      };
      lcd.clear();
      lcd.print("Tank full");
      delay(1000);
      lcd.clear();
    }

    while (millis() - startMillis < irrigationTimeMillis) {
      if(waterSource == TANK1){
        digitalWrite(tank1out, HIGH);
      }else if(waterSource == TANK2){
        digitalWrite(tank2out, HIGH);
      }else{
        digitalWrite(valvePin, HIGH);
      };

      if(raining() == 1){
        digitalWrite(pumpPin, LOW);
        break;
      }else{
        digitalWrite(pumpPin, HIGH);
      }

      lcd.setCursor(0, 0);
      lcd.print("Saver Mode ON");
      lcd.setCursor(0, 1);
      lcd.print("Watering: ");
      unsigned long timeLeft = (irrigationTimeMillis - (millis() - startMillis)) / 1000; // Time left in seconds
      lcd.print(timeLeft);
      lcd.print("s left   ");
      lcd.setCursor(0, 3);
      lcd.print("Press * to abort");

      if(Anemometer() == 1){
        return;
      }

      if (keypad.getKey() == '*') { // Abort key
        aborted();
        return;
      }
      if(timeLeft <= 0){
        lcd.setCursor(0, 1);
        lcd.print("Irrigation Complete");
        delay(1000);
        digitalWrite(pumpPin, LOW);
        digitalWrite(tank1out, LOW);
        digitalWrite(tank2out, LOW);
        digitalWrite(valvePin, LOW);
        
        break;
      }
      delay(100); // Update every second
    }
  } else {
    lcd.setCursor(0, 1);
    lcd.print("Soil moisture OK    ");
    digitalWrite(pumpPin, LOW);
    digitalWrite(tank1out, LOW);
    digitalWrite(tank2out, LOW);
    digitalWrite(valvePin, LOW);
  }
  if (keypad.getKey() == '*') { // Abort key
    aborted();
    return;
  }
}

void handleKeypadInput() {
  char key = keypad.getKey();

  if (key) {
    if (state == MAIN_MENU) {
      switch (key) {
        case '1':
          state = MODE;
          selectMode();
          break;
        case '2':
          state = SETUP;
          ModeSetup();
          break;
        case '3':
          state = CALIBRATE;
          calibrateSensors();
          break;
        case '4':
          state = REFILL_SETUP;
          refillSetup();
          break;
        default:
          break;
      }
    } else if (key == '#') {
      // Save settings and return to main menu
      state = MAIN_MENU;
      displayMainMenu();
    }
  }
}

int getIntInput(int col, int row) {
  String input = "";
  char key;
  int cursorPosition = 0; // Track the current cursor position
  lcd.setCursor(col, row);

  while (true) {
    key = keypad.getKey();
    if (key >= '0' && key <= '9') {
      input += key;
      if(state != MAIN_MENU){
        lcd.print(key);
        cursorPosition++;
      }
    } else if (key == '#') {
      break; // Confirm input
    } else if (key == '*') {
      // Handle backspace
      if (cursorPosition > 0) {
        cursorPosition--;
        input.remove(input.length() - 1);
        lcd.setCursor(col + cursorPosition, row);
        lcd.print(" ");
        lcd.setCursor(col + cursorPosition, row);
      }
    }
    if (key == 'D') { // Quit to main menu
      state = MAIN_MENU;
      displayMainMenu();
      return 9999;
    }
  }
  return input.toInt();
}

float readWindSpeed() {
  int sensorValue = analogRead(anemometerPin);
  // Assuming a linear mapping from 0 to 30 m/s
  return map(sensorValue, 0, 1023, 0, 30);
}

void aborted(){
  lcd.clear();
  lcd.setCursor(0, 1);
  lcd.print("      Aborted.      ");
  digitalWrite(pumpPin, LOW);
  if(waterSource == TANK1){
    digitalWrite(tank1out, LOW);
  }else if(waterSource == TANK2){
    digitalWrite(tank2out, LOW);
  }else{
    digitalWrite(valvePin, LOW);
  };
  delay(1000); // Brief pause before returning to the main menu
  state = MAIN_MENU;
  displayMainMenu();
}

int Anemometer(){
  int windSpeed = int(readWindSpeed());
  if (windSpeed > windSpeedThreshold) {
    lcd.setCursor(0, 1);
    lcd.print("Irrigation paused  ");
    lcd.setCursor(0, 2);
    lcd.print("High windspeed");
    digitalWrite(pumpPin, LOW);
    digitalWrite(valvePin, LOW);
    while (readWindSpeed() > windSpeedThreshold) {
      delay(1000); // Check every second
      if (keypad.getKey() == '*') { // Abort key
        aborted();
        return 1; // Exit the function
      }
    }
    //lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print("Resuming irrigation");
    lcd.setCursor(0, 2);
    lcd.print("                   ");
    delay(1000); // Brief pause before resuming
    digitalWrite(pumpPin, HIGH);
    digitalWrite(valvePin, HIGH);
    lcd.clear();
  }
  return 0;
}

int raining(){
  int rain = digitalRead(rainPin);

  if(rain == HIGH){
    if(rainTimer == 0){
      lcd.setCursor(0, 2);
      lcd.print("Raining: Paused     ");
      return 1;
    }
    lcd.setCursor(0, 2);
    char abc[22];
    sprintf(abc, "Rain: stopping in %ds", rainTimer);
    lcd.print(abc);
    rainTimer--;
    delay(1000);
    return 0;
  }else{
    lcd.setCursor(0, 2);
    lcd.print("                    ");
    rainTimer = 5;
    return 0;
  }
}

bool checkTank(int tankNumber) {
  if (tankNumber == 1) {
    return digitalRead(tank1LowSensor) == HIGH;
  } else if (tankNumber == 2) {
    return digitalRead(tank2LowSensor) == HIGH;
  }
  return false;
}

int fillTank(int tankNumber) {
  // Implement logic to fill the specified tank
  if (tankNumber == 1) {
    digitalWrite(tank1in, HIGH);
    // Add logic to stop filling when the high sensor is triggered
    while (digitalRead(tank1HighSensor) == LOW) {
      // Wait until tank is full
      digitalWrite(tank1fill, HIGH);

      if (keypad.getKey() == '*') { // Abort key
        digitalWrite(tank1in, LOW);
        digitalWrite(tank1fill, LOW);
        aborted();
        return 1; // Exit the function
      }
    }
    digitalWrite(tank1in, LOW);
    digitalWrite(tank1fill, LOW);
  } else if (tankNumber == 2) {
    digitalWrite(tank2in, HIGH);
    // Add logic to stop filling when the high sensor is triggered
    while (digitalRead(tank2HighSensor) == LOW) {
      // Wait until tank is full
      digitalWrite(tank2fill, HIGH);

      if (keypad.getKey() == '*') { // Abort key
        digitalWrite(tank2in, LOW);
        digitalWrite(tank2fill, LOW);
        aborted();
        return; // Exit the function
      }
    }
    digitalWrite(tank2in, LOW);
    digitalWrite(tank2fill, LOW);
  }
  return;
}

/*void checkSource(int tankNumber){
  if ((waterSource == TANK1 && !checkTank(1)) || (waterSource == TANK2 && !checkTank(2))) {
    lcd.clear();
    lcd.setCursor(0, 0);
    char abc[10];
    sprintf(abc, "Filling Tank %d.", tankNumber);
    lcd.print(abc);
    fillTank(waterSource);
    lcd.clear();
    lcd.print("Tank full");
    delay(1000);
    lcd.clear();
  }
  return 0;
}*/