/// INI LIFT ///

#include <Keypad.h>
#include <LedControl.h>

// Pinout Dot Matrix
const int numberOfMatrices = 2;
// DIN, CLK, CS = 2, 3, 4,
LedControl lc = LedControl(2, 3, 4, numberOfMatrices);
const int matrixDelay = 500;
const int blinkDelay = 250;

// Pinout Keypad
const byte numRows = 4;
const byte numCols = 4;
byte rowPins[numRows] = {5, 6, 7, 8};    // ke bawah (baris/R)
byte colPins[numCols] = {9, 10, 11, 12}; // ke samping (kolom/C)
char keymap[numRows][numCols] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'G', '0', 'E', 'D'}
};
Keypad keypad = Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);

int currentNumber = 0;

//https://embed.plnkr.co/3VUsekP3jC5xwSIQDVHx
const byte digitPatterns[15][8] = { 
  {B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}, //kosong
  {B00100000,B00110000,B00100000,B00100000,B00100000,B00100000,B00100000,B00000000}, //1
  {B01110000,B10001000,B10000000,B01000000,B00100000,B00010000,B11111000,B00000000}, //2
  {B01110000,B10001000,B10000000,B01100000,B10000000,B10001000,B01110000,B00000000}, //3
  {B01000000,B01100000,B01010000,B01001000,B11111000,B01000000,B01000000,B00000000}, //4
  {B11111000,B00001000,B01111000,B10000000,B10000000,B10001000,B01110000,B00000000}, //5
  {B01110000,B00001000,B00001000,B01111000,B10001000,B10001000,B01110000,B00000000}, //6
  {B11111000,B10000000,B01000000,B00100000,B00010000,B00010000,B00010000,B00000000}, //7
  {B01110000,B10001000,B10001000,B01110000,B10001000,B10001000,B01110000,B00000000}, //8
  {B01110000,B10001000,B10001000,B11110000,B10000000,B10001000,B01110000,B00000000}, //9
  {B01111000,B10001000,B10001000,B01111000,B10001000,B10001000,B01111000,B00000000}, //10(B)
  {B00100001,B00110010,B00100010,B00100001,B00100010,B00100010,B00100001,B00000000}, //B1_B
  {B11100000,B00100000,B00100000,B11100000,B00100000,B00100000,B11100000,B00000000}, //B1_1
  {B01110000,B10001000,B10001000,B10001000,B10001000,B10001000,B01110000,B00000000}, //10_1
  {B10000000,B11000000,B10000000,B10000000,B10000000,B10000000,B10000000,B00000000}  //10_0
};
const byte charPatterns[8][8] = { 
  {B00001010,B00010001,B00100000,B01000000,B00100000,B00010001,B00001010,B00000000}, //<>_<
  {B00000000,B00000000,B10000000,B01000000,B10000000,B00000000,B00000000,B00000000}, //<>_>
  {B01000000,B00100000,B00010001,B00001010,B00010001,B00100000,B01000000,B00000000}, //><_>
  {B01000000,B10000000,B00000000,B00000000,B00000000,B10000000,B01000000,B00000000}, //><_<
  {B00000100,B00001110,B00010101,B00000100,B00000100,B00000100,B00000100,B00000000}, //atas(4)
  {B00000100,B00000100,B00000100,B00000100,B00010101,B00001110,B00000100,B00000000}, //bawah
  {B10000100,B11000100,B10000100,B10000100,B10010101,B10001110,B10000100,B00000000}, //bawah1
  {B11100100,B00101110,B00110101,B11100100,B00100100,B00100100,B11100100,B00000000}  //atasB(7)
};




void setup() {  
  lc.shutdown(0, false);
  lc.shutdown(1, false);

  lc.setIntensity(0, 8);
  lc.setIntensity(1, 8);

  lc.clearDisplay(0);
  lc.clearDisplay(1);
}

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

  if (key) {
    int targetNumber = key - '0';
    
    if (key == 'A' || key == 'B' ||
        key == 'C' || key == 'D') {
      displayString(key);  
      blinkString(key);
    } else {
      if (key == 'E'){
        targetNumber = 10;
      }
      (targetNumber > currentNumber) ? incrementNumber(targetNumber) : decrementNumber(targetNumber);
      blinkNumber(targetNumber);
    }
    delay(2000);
    clearDisplay();
  }
}

void incrementNumber(int target) {
  for (int i = currentNumber; i <= target && i <= 10; i++) {
    displayNumber(i);
    if (i == 10){
      displayChar(1, 6);
    } else if (i == 0){
      displayChar(1, 7);
    } else {
      displayChar(1, 4);
    }
    delay(matrixDelay);
  }
}

void decrementNumber(int target) {
  for (int i = currentNumber; i >= target && i >= 0; i--) {
    displayNumber(i);
    if (i == 10){
      displayChar(1, 6);
    } else if (i == 0){
      displayChar(1, 7);
    } else {
      displayChar(1, 5);
    }
    delay(matrixDelay);
  }
}

void displayNumber(int num) {
  lc.clearDisplay(0);
  lc.clearDisplay(1);

  if(num > 0 && num < 10){
    displayDigit(0, num);
  } else if (num == 0) {
    //munculkan B1
    displayDigit(0, 11);
    displayDigit(1, 12);
    // //munculkan B aja
    // //displayDigit(0, 10);
  } else if (num == 10) {
    // munculkan angka 10
    displayDigit(0, 13);
    displayDigit(1, 14);
  }
  delay(matrixDelay);
  currentNumber = num;
}

void displayDigit(int matrix, int digit) {
  for (int col = 0; col < 8; col++) {
    byte columnData = B00000000;

    for (int row = 0; row < 8; row++) {
      if (digitPatterns[digit][col] & (1 << row)) {
        columnData |= (1 << row);
      }
    }
    lc.setRow(matrix, col, columnData);
  }
}

void displayString(char ch) {
  lc.clearDisplay(0);
  lc.clearDisplay(1);

  if(ch == 'A'){
    // Munculkan <>
    displayChar(0, 0);
    displayChar(1, 1);
  } else if(ch == 'B'){
    // Munculkan ><
    displayChar(0, 2);
    displayChar(1, 3);
  }
  delay(matrixDelay);
}

void displayChar(int matrix, char ch) {
  for (int col = 0; col < 8; col++) {
    byte columnData = B00000000;

    for (int row = 0; row < 8; row++) {
      if (charPatterns[ch][col] & (1 << row)) {
        columnData |= (1 << row);
      }
    }
    lc.setRow(matrix, col, columnData);
  }
}

void blinkString(char ch) {
  for (int i = 0; i < 5; i++) {
    displayString(ch);
    delay(blinkDelay);
    clearDisplay();
    delay(blinkDelay);
  }
}

void blinkNumber(int num) {
  for (int i = 0; i < 5; i++) {
    displayNumber(num);
    delay(blinkDelay);
    clearDisplay();
    delay(blinkDelay);
  }
}

void clearDisplay() {
  lc.clearDisplay(0);
  lc.clearDisplay(1);
}