#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 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() {
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Welcome Press");
  lcd.setCursor(0, 1);
  lcd.print(" D for Menu");
}

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");

      while (true) {  // Wait for user input to either continue selection or start printing
        char key = keypad.getKey();
        if (key == '#') {
          break;  // Break out to allow selecting another design
        } else if (key == 'C') {
          startPrintingDesigns();  // Start printing immediately
          return;
        }
      }
    } else {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Invalid Design No");
      delay(2000);
    }
  }

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Press C to Start");

  while (true) {
    char key = keypad.getKey();
    if (key == 'C') {
      startPrintingDesigns();
      break;
    }
  }
}


void startPrintingDesigns() {
  int runCounter = 0;  // Counter to track how many times the full sequence is run
  bool continuePrinting = true;

  while (continuePrinting) {
    runCounter++;

    for (int i = 0; i < selectedDesignCount; i++) {
      Design selectedDesign = designs[selectedDesigns[i].designNumber - 1];
      int repeatCount = selectedDesigns[i].repeatCount;

      for (int j = 0; j < repeatCount; j++) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Design D");
        lcd.print(selectedDesigns[i].designNumber);
        lcd.setCursor(0, 1);
        lcd.print("Run Count: ");
        lcd.print(runCounter);
        lcd.setCursor(0, 2);
        lcd.print("Repeat: ");
        lcd.print(j + 1);
        delay(2000);

        for (int k = 0; k < selectedDesign.boxCount; k++) {
          int boxIndex = selectedDesign.order[k] - 1;  // Adjust this to the selected box
          String boxLabel = "Box " + String(selectedDesign.order[k]);
          continuePrinting = printPickCount(boxLabel, selectedDesign.picks[boxIndex], runCounter);
          if (!continuePrinting) break;
        }

        if (!continuePrinting) break;
      }

      if (!continuePrinting) break;
    }

    if (!continuePrinting) break;

    // Check for C to stop
    char stopKey = keypad.getKey();
    if (stopKey == 'C') {
      continuePrinting = false;
    }
  }

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

int getInput() {
  String input = "";
  char key;
  while (true) {
    key = keypad.getKey();
    if (key && key >= '0' && key <= '9') {
      input += key;
      lcd.print(key);
    }
    if (key == '#') { // # is the Enter key
      break;
    }
  }
  return input.toInt();
}

bool printPickCount(String boxLabel, int picks, int runCounter) {
  for (int i = 1; i <= picks; i++) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(boxLabel + " Pick: ");
    lcd.print(i);
    lcd.setCursor(0, 2);
    lcd.print("Run Count: ");
    lcd.print(runCounter);
    delay(2000); // 2-second interval between each pick

    // Check if 'C' is pressed during the pick count
    char key = keypad.getKey();
    if (key == 'C') {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Design Stopped");
      delay(2000);
      return false; // Stop the pick count and exit
    }
  }
  return true; // Continue the design process
}