/*
  Using custom sprites (icons), drawSprite(), drawMenu() and preview callbacks in GEM library.

  Simple two page menu with bool variable, byte option select and a button, pressing of which will result in 
  changing its title, overriding its icon, and toggling bool variable. Changing value of volume variable
  via option select will result in updatig volume icon in title bar (including real-time preview of a value)
  unless bool variable indicating muted status is set to true. Small play icon is also drawn in title bar
  when bool variable is set to true.

  Second menu page with two option selects is added: one option select changes appearance of a menu pointer,
  another - set of sprites (icons) being used to draw UI elements of a menu.

  U8g2lib library is used to draw menu.
  KeyDetector library (version 1.2.0 or later) is used to detect rotary encoder operation.
  
  Additional info (including the breadboard view) available on GitHub:
  https://github.com/Spirik/GEM
  
  This example code is in the public domain.
*/

#include <GEM_u8g2.h>
#include <KeyDetector.h>

// Custom icons are stored here
#include "sprites-u8g2-custom.h"

// Define signal identifiers for three outputs of encoder (channel A, channel B and a push-button)
#define KEY_A 1
#define KEY_B 2
#define KEY_C 3

// Pins encoder is connected to
const byte channelA = 2;
const byte channelB = 3;
const byte buttonPin = 4;

byte chanB = HIGH; // Variable to store Channel B readings

// Array of Key objects that will link GEM key identifiers with dedicated pins
// (it is only necessary to detect signal change on a single channel of the encoder, either A or B;
// order of the channel and push-button Key objects in an array is not important)
Key keys[] = {{KEY_A, channelA}, {KEY_C, buttonPin}};
//Key keys[] = {{KEY_C, buttonPin}, {KEY_A, channelA}};

// Create KeyDetector object
// KeyDetector myKeyDetector(keys, sizeof(keys)/sizeof(Key));
// To account for switch bounce effect of the buttons (if occur) you may want to specify debounceDelay
// as the third argument to KeyDetector constructor.
// Make sure to adjust debounce delay to better fit your rotary encoder.
// Also it is possible to enable pull-up mode when buttons wired with pull-up resistors (as in this case).
// Analog threshold is not necessary for this example and is set to default value 16.
KeyDetector myKeyDetector(keys, sizeof(keys)/sizeof(Key), /* debounceDelay= */ 5, /* analogThreshold= */ 16, /* pullup= */ true);

bool secondaryPressed = false;  // If encoder rotated while key was being pressed; used to prevent unwanted triggers
bool cancelPressed = false;  // Flag indicating that Cancel action was triggered, used to prevent it from triggering multiple times
const int keyPressDelay = 1000; // How long to hold key in pressed state to trigger Cancel action, ms
long keyPressTime = 0; // Variable to hold time of the key press event
long now; // Variable to hold current time taken with millis() function at the beginning of loop()

// Create an instance of the U8g2 library.
// Use constructor that matches your setup (see https://github.com/olikraus/u8g2/wiki/u8g2setupcpp for details).
// This instance is used to call all the subsequent U8g2 functions (internally from GEM library,
// or manually in your sketch if it is required).
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);

// Define a custom ID that will help to identify specific button
// (normally it would be an int or a byte but we are using string here for demonstration purposes)
#define PLAY_BUTTON_ID "play_button"

// Create variable that holds current play/pause status and assign initial value
bool isPlaying = false;

// Create variable that holds muted status and will be editable through the menu and assign initial value
bool isMuted = false;

// Create variable holding volume level that will be editable through option select and create associated option select
byte volumeLevel = 4; // Volume level set by the following select
byte volumeLevelHW = volumeLevel; // Volume level presumably sent to an actual hardware (also used to draw volume level icon in status bar in preview callback)
SelectOptionByte selectVolumeOptions[] = {{"0%", 0}, {"25%", 1}, {"50%", 2}, {"75%", 3}, {"100%", 4}};
GEMSelect selectVolume(sizeof(selectVolumeOptions)/sizeof(SelectOptionByte), selectVolumeOptions);

// Create menu item for volume option select with applyVolume() callback function
void applyVolume(); // Forward declaration
GEMItem menuItemVolume("Volume:", volumeLevel, selectVolume, applyVolume);

// Create menu item object of class GEMItem, linked to isMuted variable, with applyMuted() callback function
void applyMuted(); // Forward declaration
GEMItem menuItemBool("Mute:", isMuted, applyMuted);

// Create menu button that will trigger togglePlay() function.
// We should forward-declare it in order to pass to GEMItem constructor
void togglePlay(GEMCallbackData callbackData); // Forward declaration
// Set a custom ID associated with a button to help to identify it later in togglePlay() and/or drawCustomIcon() callbacks
GEMItem menuItemButton("Play", togglePlay, PLAY_BUTTON_ID);

// Create variable holding appearance of menu pointer that will be editable through option select and create associated option select
byte menuPointer = GEM_POINTER_ROW;
SelectOptionByte selectMenuPointerOptions[] = {{"Row", GEM_POINTER_ROW}, {"Dash", GEM_POINTER_DASH}};
GEMSelect selectMenuPointer(sizeof(selectMenuPointerOptions)/sizeof(SelectOptionByte), selectMenuPointerOptions);

// Create menu item for option select with applyMenuPointer() callback function
void applyMenuPointer(); // Forward declaration
GEMItem menuItemMenuPointer("Menu pointer:", menuPointer, selectMenuPointer, applyMenuPointer);

// Array of pointers to sprites (nullptr for using default set of UI icons), a.k.a. themes
void* themes[2] = {nullptr, spritesCustom};

// Create variable holding index of UI icon set (theme) being used that will be editable through option select and create associated option select
byte themeIndex = 1;
SelectOptionByte selectThemeIndexOptions[] = {{"Basic", 0}, {"Custom", 1}};
GEMSelect selectThemeIndex(sizeof(selectThemeIndexOptions)/sizeof(SelectOptionByte), selectThemeIndexOptions);

// Create menu item for option select with applyThemeIndex() callback function
void applyThemeIndex(); // Forward declaration
GEMItem menuItemThemeIndex("UI theme:", themeIndex, selectThemeIndex, applyThemeIndex);

// Create menu page object of class GEMPage. Menu page holds menu items (GEMItem) and represents menu level.
// Menu can have multiple menu pages (linked to each other) with multiple menu items each
GEMPage menuPageMain("Player"); // Main page
GEMPage menuPageSettings("Settings"); // Settings submenu

// Create menu item linked to Settings menu page
GEMItem menuItemMainSettings("Settings", menuPageSettings);

// Create GEMAppearance object
GEMAppearance appearanceGeneral;

// Create menu object of class GEM_u8g2. Supply its constructor with reference to u8g2 object we created earlier
GEM_u8g2 menu(u8g2);

void setup() {
  // Pin modes
  pinMode(channelA, INPUT_PULLUP);
  pinMode(channelB, INPUT_PULLUP);
  pinMode(buttonPin, INPUT_PULLUP);

  // Serial communication setup
  Serial.begin(115200);

  // U8g2 library init
  u8g2.begin();

  // Set custom splash
  menu.setSplash(logo);

  // Menu init, setup and draw
  menu.init();
  setupMenu();
  menu.drawMenu();

  Serial.println("Initialized");
}

void setupMenu() {
  // Populate GEMAppearance object with general values (that will be used for every menu page if not overridden)
  appearanceGeneral.menuPointerType = menuPointer;
  appearanceGeneral.menuItemsPerScreen = GEM_ITEMS_COUNT_AUTO;
  appearanceGeneral.menuItemHeight = 10;
  appearanceGeneral.menuPageScreenTopOffset = 10;
  appearanceGeneral.menuValuesLeftOffset = 86;
  appearanceGeneral.sprites = themes[themeIndex]; // Set currently applied set of UI icons (a.k.a. theme)

  // Set appearanceGeneral as a general appearance of the menu
  menu.setAppearance(appearanceGeneral);

  // Set callback that will be called when icon is drawn
  menu.setDrawSpriteCallback(drawCustomIcon);

  // Set callback that will be called at the end of drawMenu()
  // and draw play icon in title bar when isPlaying is true
  menu.setDrawMenuCallback(drawStatus);

  // Set preview callback for volume select
  menuItemVolume.setPreviewCallback(previewVolume);

  // Add menu items to Settings menu page
  menuPageSettings
    .addMenuItem(menuItemMenuPointer)
    .addMenuItem(menuItemThemeIndex);

  // Add menu items to Main menu page
  menuPageMain
    .addMenuItem(menuItemMainSettings)
    .addMenuItem(menuItemVolume)
    .addMenuItem(menuItemBool)
    .addMenuItem(menuItemButton);

  // Specify parent menu page for the Settings menu page
  menuPageSettings.setParentMenuPage(menuPageMain);

  // Add menu page to menu and set it as current
  menu.setMenuPageCurrent(menuPageMain);
}

void loop() {
  // Get current time to use later on
  now = millis();

  // If menu is ready to accept button press...
  if (menu.readyForKey()) {
    chanB = digitalRead(channelB); // Reading Channel B signal beforehand to account for possible delays due to polling nature of KeyDetector algorithm
    // ...detect key press using KeyDetector library
    // and pass pressed button to menu
    myKeyDetector.detect();
  
    switch (myKeyDetector.trigger) {
      case KEY_A:
        // Signal from Channel A of encoder was detected
        if (chanB == LOW) {
          // If channel B is low then the knob was rotated CCW
          if (myKeyDetector.current == KEY_C) {
            // If push-button was pressed at that time, then treat this action as GEM_KEY_LEFT,...
            menu.registerKeyPress(GEM_KEY_LEFT);
            // Button was in a pressed state during rotation of the knob, acting as a modifier to rotation action
            secondaryPressed = true;
          } else {
            // ...or GEM_KEY_UP otherwise
            menu.registerKeyPress(GEM_KEY_UP);
          }
        } else {
          // If channel B is high then the knob was rotated CW
          if (myKeyDetector.current == KEY_C) {
            // If push-button was pressed at that time, then treat this action as GEM_KEY_RIGHT,...
            menu.registerKeyPress(GEM_KEY_RIGHT);
            // Button was in a pressed state during rotation of the knob, acting as a modifier to rotation action
            secondaryPressed = true;
          } else {
            // ...or GEM_KEY_DOWN otherwise
            menu.registerKeyPress(GEM_KEY_DOWN);
          }
        }
        break;
      case KEY_C:
        // Button was pressed
        // Save current time as a time of the key press event
        keyPressTime = now;
        break;
    }
    switch (myKeyDetector.triggerRelease) {
      case KEY_C:
        // Button was released
        if (!secondaryPressed) {
          // If button was not used as a modifier to rotation action...
          if (now <= keyPressTime + keyPressDelay) {
            // ...and if not enough time passed since keyPressTime,
            // treat key that was pressed as Ok button
            menu.registerKeyPress(GEM_KEY_OK);
          }
        }
        secondaryPressed = false;
        cancelPressed = false;
        break;
    }
    // After keyPressDelay passed since keyPressTime
    if (now > keyPressTime + keyPressDelay) {
      switch (myKeyDetector.current) {
        case KEY_C:
          if (!secondaryPressed && !cancelPressed) {
            // If button was not used as a modifier to rotation action, and Cancel action was not triggered yet
            // Treat key that was pressed as Cancel button
            menu.registerKeyPress(GEM_KEY_CANCEL);
            cancelPressed = true;
          }
          break;
      }
    }
  }
}

/* Some useful methods */

void applyHardwareVolume() {
  // Pretend to do something useful here with an actual hardware,
  // e.g. send volume setting to sound processor, amplifier, etc.
}

/* Save callbacks */

void applyVolume() {
  // Assign hardware volume only if not muted
  if (!isMuted) {
    volumeLevelHW = volumeLevel;
    applyHardwareVolume();
  }

  // Print volumeLevel variable to Serial
  Serial.print(F("Volume set: "));
  Serial.println(volumeLevel);
}

void applyMuted() {
  // Assign hardware volume based on muted status
  if (isMuted) {
    volumeLevelHW = 0;
  } else {
    volumeLevelHW = volumeLevel;
  }
  applyHardwareVolume();

  // Print isMuted variable to Serial
  Serial.print(F("Mute: "));
  Serial.println(isMuted);
}

void applyMenuPointer() {
  appearanceGeneral.menuPointerType = menuPointer;
  menu.setAppearance(appearanceGeneral); // Need to call setAppearance() when changing general appearance

  // Print menuPointer variable to Serial
  Serial.print(F("Menu pointer set: "));
  Serial.println(menuPointer);
}

void applyThemeIndex() {
  appearanceGeneral.sprites = themes[themeIndex];
  menu.setAppearance(appearanceGeneral); // Need to call setAppearance() when changing general appearance

  // Print selected theme name to Serial
  Serial.print(F("Theme set: "));
  Serial.println(selectThemeIndexOptions[themeIndex].name);
}

void togglePlay(GEMCallbackData callbackData) {
  // Toggle isPlaying status and update button title accordingly
  isPlaying = !isPlaying;
  callbackData.pMenuItem->setTitle(isPlaying ? "Pause" : "Play");
  menu.drawMenu();
  Serial.print(F("Status is: "));
  Serial.println(isPlaying ? F("playing") : F("paused"));
}

/* Draw callbacks */

bool drawCustomIcon(u8g2_uint_t x, u8g2_uint_t y, byte spriteId, GEMItem* menuItem) {
  // Validity check: we only want to override an icon of a specific button...
  if (spriteId == GEM_ICON_ARROW_BTN && menuItem != nullptr) {
    const char* buttonId = menuItem->getCallbackData().valChar;

    // ...and that button has an ID attached to it as a part of GEMCallbackData object
    if (buttonId == PLAY_BUTTON_ID) {
      Serial.print(F("Draw icon"));
      Serial.print(F(" at (x: "));
      Serial.print(x);
      Serial.print(F(", y: "));
      Serial.print(y);
      Serial.print(F(")"));

      Serial.print(F(" for \""));
      Serial.print(buttonId);
      Serial.print(F("\""));

      const char* title = menuItem->getTitle();
      Serial.print(F(" with title \""));
      Serial.print(title);
      Serial.print(F("\""));

      // Check if menu item (i.e. our button) is currently focused
      GEMPage* currentMenuPage = menu.getCurrentMenuPage();
      GEMItem* currentMenuItem = currentMenuPage->getCurrentMenuItem();
      if (menuItem == currentMenuItem) {
        Serial.print(F(" (focused)"));
      }

      Serial.println();

      // Draw different versions of icon based on isPlaying status (and only if custom UI icon set (theme) is selected)
      if (themes[themeIndex] != nullptr) {
        if (isPlaying) {
          u8g2.drawXBMP(x-1, y, arrowBtn_pause.width, arrowBtn_pause.height, arrowBtn_pause.image);
        } else {
          u8g2.drawXBMP(x-1, y, arrowBtn_play.width, arrowBtn_play.height, arrowBtn_play.image);
        }
      }

      // Return false to skip drawing default icon (if custom UI icon set (theme) is selected)
      if (themes[themeIndex] != nullptr) {
        return false;
      }
    }
  }

  // Return true to draw default icon
  return true;
}

void drawStatus() {
  drawPlayIcon();
  drawVolumeIcon();
}

void drawPlayIcon() {
  if (isPlaying) {
    u8g2.drawXBMP((u8g2.getDisplayWidth() - status_play.width) - 12, 2, status_play.width, status_play.height, status_play.image);
  }
}

void drawVolumeIcon() {
  u8g2.drawXBMP((u8g2.getDisplayWidth() - volumeIcons[volumeLevelHW].width) - 1, 1, volumeIcons[volumeLevelHW].width, volumeIcons[volumeLevelHW].height, volumeIcons[volumeLevelHW].image);
}

/* Preview callbacks */

void previewVolume(GEMPreviewCallbackData previewData) {
  const int selectedIndex = previewData.previewSelectNum;
  if (selectedIndex != -1) {
    Serial.print(F(".previewSelectNum: "));
    Serial.print(selectedIndex);
    Serial.print(F(" | Name: "));
    Serial.print(selectVolumeOptions[selectedIndex].name);
    Serial.print(F(" | Val: "));
    Serial.println(selectVolumeOptions[selectedIndex].val_byte);
    // Update hardware volume and redraw icon in status bar only if not muted
    if (!isMuted) {
      volumeLevelHW = selectVolumeOptions[selectedIndex].val_byte;
      applyHardwareVolume();
      drawVolumeIcon();
    }
  } else {
    Serial.print(F("Cancel. Original value remains: "));
    Serial.println(volumeLevel);
    applyVolume();
  }
}