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

// Initialize keypad
const byte ROWS = 4; // Number of rows on the keypad
const byte COLS = 4; // Number of columns on the keypad
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {13, 12, 14, 27}; 
byte colPins[COLS] = {26, 25, 33, 32}; 
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

// Initialize LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);

// Define relay pins for each box
const int relayPins[4] = {19, 18, 5, 4}; // Example pins for the relays
const int limitSwitchPin = 35; // Example pin for the limit switch
const int laserSensorPin = 34; // Example pin for the laser sensor

int count = 0;  // Initialize count for laser interruptions

// Define a structure to hold design settings
struct Design {
  int repeatSize;
  int picks[4];
  int order[4];
  int boxCount;
  bool isSaved;
};

// Create an array to store up to 20 designs
Design designs[20];
int currentDesignIndex = 0; // To keep track of how many designs have been saved

// Define a structure to hold selected design settings
struct SelectedDesign {
  int designNumber;
  int repeatCount;
};

// Create an array to store up to 10 selected designs
SelectedDesign selectedDesigns[10];
int selectedDesignCount = 0; // To keep track of selected designs

void setup() {

  Serial.begin(115200); 

  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Welcome Press");
  lcd.setCursor(0, 1);
  lcd.print(" D for Menu");

  // Initialize relay pins as outputs and set them to LOW
  for (int i = 0; i < 4; i++) {
    pinMode(relayPins[i], OUTPUT);
    digitalWrite(relayPins[i], LOW);
  }

  // Initialize limit switch and laser sensor pins as inputs with pull-up resistors
  pinMode(limitSwitchPin, INPUT_PULLUP);
  pinMode(laserSensorPin, INPUT);
}

void loop() {
  char key = keypad.getKey();
  if (key) {
    if (key == 'D') {
      showMenu();
    } 
  }
}

void showMenu() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("1: Design Create");
  lcd.setCursor(0, 1);
  lcd.print("2: Saved Design");

  char key;
  while (true) {
    key = keypad.getKey();
    if (key) {
      handleMenuInput(key);
      break;
    }
  }
}

void handleMenuInput(char key) {
  switch (key) {
    case '1': {
      createDesign();
      break;
    }
    case '2': {
      selectDesignsForExecution();
      break;
    }
    default: {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Invalid Option");
      delay(1000);
      showMenu();
      break;
    }
  }
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Welcome Press");
  lcd.setCursor(0, 1);
  lcd.print(" D for Menu");
}

void createDesign() {
  if (currentDesignIndex < 20) { // Ensure we do not exceed 20 designs
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Enter Repeat Size:");
    int repeatSize = getInput(); // Get user input for repeat size
    char key;

    int picks[4] = {0, 0, 0, 0};
    int order[4] = {0, 0, 0, 0};
    int boxCount = 0;
    bool isDesignComplete = false;

    // Loop to allow selection of different boxes
    while (!isDesignComplete && boxCount < 4) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Select Box 1-4:");
      lcd.setCursor(0, 1);
      lcd.print("# to Save, B to Cancel");

      while (true) {
        char key = keypad.getKey();
        if (key) {
          if (key >= '1' && key <= '4') {
            int selectedBox = key - '0';

            bool alreadySelected = false;
            for (int i = 0; i < boxCount; i++) {
              if (order[i] == selectedBox) {
                alreadySelected = true;
                break;
              }
            }

            if (!alreadySelected) {
              order[boxCount] = selectedBox;
              boxCount++;

              lcd.clear();
              lcd.setCursor(0, 0);
              lcd.print("Box ");
              lcd.print(selectedBox);
              lcd.print(" Picks:");
              picks[selectedBox - 1] = getInput();
            } else {
              lcd.clear();
              lcd.setCursor(0, 0);
              lcd.print("Box Already Sel.");
              delay(2000);
            }
          } else if (key == '#') {
            // Save the design
            int totalPicks = 0;
            for (int i = 0; i < 4; i++) {
              totalPicks += picks[i];
            }

            if (totalPicks == repeatSize) {
              designs[currentDesignIndex].repeatSize = repeatSize;
              for (int i = 0; i < 4; i++) {
                designs[currentDesignIndex].picks[i] = picks[i];
                designs[currentDesignIndex].order[i] = order[i];
              }
              designs[currentDesignIndex].boxCount = boxCount;
              designs[currentDesignIndex].isSaved = true;
              currentDesignIndex++;

              lcd.clear();
              lcd.setCursor(0, 0);
              lcd.print("Design Saved!");
              delay(2000);
              isDesignComplete = true;
            } else {
              lcd.clear();
              lcd.setCursor(0, 0);
              lcd.print("Error: Picks !=");
              lcd.setCursor(0, 1);
              lcd.print("Repeat Size");
              delay(2000);
            }
          } else if (key == 'B') {
            lcd.clear();
            lcd.setCursor(0, 0);
            lcd.print("Cancelled");
            delay(2000);
            isDesignComplete = true;
          }
          break;
        }
      }
    }

    // Show saved picks (if design was saved)
    if (isDesignComplete && key != 'B') {
      for (int i = 0; i < boxCount; i++) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Box ");
        lcd.print(order[i]);
        lcd.print(": ");
        lcd.print(picks[order[i] - 1]);
        delay(2000);
      }
    }

  } else {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Memory Full");
    delay(2000);
  }
}

void selectDesignsForExecution() {
  selectedDesignCount = 0;  // Reset the selection count

  while (selectedDesignCount < 10) {  // Allow up to 10 design selections
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Select Design (1-20):");

    int designNumber = getInput(); // Get user input for design number

    if (designNumber >= 1 && designNumber <= 20 && designs[designNumber - 1].isSaved) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Enter Repeat Count:");

      int repeatCount = getInput();  // Get the repeat count for the selected design
      selectedDesigns[selectedDesignCount].designNumber = designNumber;
      selectedDesigns[selectedDesignCount].repeatCount = repeatCount;
      selectedDesignCount++;

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Added: D");
      lcd.print(designNumber);
      lcd.print(" x ");
      lcd.print(repeatCount);
      delay(2000);

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Press # to Add More");
      lcd.setCursor(0, 1);
      lcd.print("Press C to Start");

      Serial.println("In selectDesignsForExecution() while true ");

      while (true) {  // Wait for user input to either continue selection or start printing

        Serial.println("Waiting for    #   and     C  ");
        char key = keypad.getKey();
        if (key == '#') {
          Serial.println("Entered # so breaking tha statement .........");
          break;  // Break out to allow selecting another design
        } else if (key == 'C') {
          Serial.println("Entered     C   calling startPrintingDesigns .........");
          startPrintingDesigns();  // Start printing immediately
          Serial.println("Entered     C   completed  .........!!!!!!!");
          return;
        }
      }
    } else {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Invalid Design No..!");
      Serial.println("Invalid Design No..!");

      delay(1000);
    }
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Max Designs Added");
  delay(2000);
  startPrintingDesigns();  // If max designs selected, start printing
}


void startPrintingDesigns() {
  for (int i = 0; i < selectedDesignCount; i++) {
    int designNumber = selectedDesigns[i].designNumber;
    int repeatCount = selectedDesigns[i].repeatCount;

    for (int j = 0; j < repeatCount; j++) {
      executeDesign(designNumber);
    }
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Printing Complete");
  delay(2000);
}

void executeDesign(int designNumber) {

  
  Design selectedDesign = designs[designNumber - 1];

  for (int i = 0; i < selectedDesign.boxCount; i++) {
    int box = selectedDesign.order[i];
    int pickCount = selectedDesign.picks[box - 1];

    for (int j = 0; j < pickCount; j++) {
      // Wait for the laser beam to be interrupted (laser sensor triggers)
      while (digitalRead(laserSensorPin) == HIGH) {
        // Waiting for the laser beam to be interrupted
      }

      // Increase count when the laser beam is interrupted
      count++;

      // Check the limit switch status
      if (digitalRead(limitSwitchPin) == LOW) {  // Assuming LOW means the switch is pressed
        // Activate relay for the box
        digitalWrite(relayPins[box - 1], HIGH);

        // Simulate the relay action (e.g., pick operation)
        delay(1000);  // Adjust the delay as needed

        // Deactivate relay after pick
        digitalWrite(relayPins[box - 1], LOW);
        delay(1000);  // Delay for relay deactivation
      }
    }
  }
}

int getInput() {
  int value = 0;
  char key;
  while (true) {
    key = keypad.getKey();
    if (key >= '0' && key <= '9') {
      value = value * 10 + (key - '0');
      lcd.print(key);  // Display the entered number on the LCD
    } else if (key == '#') {  // Confirm input with the '#' key
      return value;
    }
  }
}