const int DATA_PIN  = 41;
const int CLK_PIN   = 42;

const int ENABLE_PIN = 15;

const int ADDERSS_0_PIN = 18;
const int ADDERSS_1_PIN = 17;
const int ADDERSS_2_PIN = 16;

// המערך הדו-ממדי שלך שמייצג את מצב המסך/לדים בפועל
bool roomOutputs[8][8] = {
  {0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0},
  {0,0,0,0,0,0,0,0}
};

// פונט עברית תעשייתי מכווץ - 8 בתים לכל אות (כל בית מייצג שורה במטריצה)
// תוקן כיוון האותיות והרגליים (כולל הרגל היוצאת של ה-ת')
const uint8_t hebrew_font[27][8] = {
    {0x00, 0xC6, 0xCC, 0x7E, 0x36, 0x66, 0xC6, 0x00}, // א
    {0x00, 0x7E, 0x7E, 0x60, 0x60, 0xFE, 0xFE, 0x00}, // ב
    {0x00, 0x3C, 0x3C, 0x30, 0x38, 0x6C, 0x6C, 0x00}, // ג
    {0x00, 0xFF, 0xFF, 0x60, 0x60, 0x60, 0x60, 0x00}, // ד
    {0x00, 0x7E, 0x7E, 0x60, 0x66, 0x66, 0x66, 0x00}, // ה
    {0x00, 0x3C, 0x3C, 0x30, 0x30, 0x30, 0x30, 0x00}, // ו
    {0x00, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x00}, // ז
    {0x00, 0x7E, 0x7E, 0x66, 0x66, 0x66, 0x66, 0x00}, // ח
    {0x00, 0xE3, 0xF3, 0xDB, 0xC3, 0xC3, 0xFF, 0x00}, // ט
    {0x00, 0x3C, 0x3C, 0x30, 0x30, 0x00, 0x00, 0x00}, // י
    {0x7E, 0x7E, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60}, // ך
    {0x00, 0x7E, 0x7E, 0x60, 0x60, 0x7E, 0x7E, 0x00}, // כ
    {0x06, 0x06, 0x7E, 0x7E, 0x60, 0x60, 0x30, 0x18}, // ל
    {0x00, 0x7E, 0x7E, 0x66, 0x66, 0x7E, 0x7E, 0x00}, // ם
    {0x00, 0x3B, 0x7B, 0x6F, 0x67, 0x7B, 0x7B, 0x00}, // מ
    {0x78, 0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60}, // ן
    {0x00, 0x70, 0x70, 0x60, 0x60, 0x78, 0x78, 0x00}, // נ
    {0x00, 0x7E, 0x7E, 0x66, 0x66, 0x3E, 0x1E, 0x00}, // ס
    {0x00, 0xD8, 0xD8, 0xD8, 0xD8, 0xFE, 0x7E, 0x00}, // ע
    {0x7E, 0x7E, 0x6C, 0x60, 0x60, 0x60, 0x60, 0x60}, // ף
    {0x00, 0x7E, 0x7E, 0x6C, 0x60, 0x7E, 0x7E, 0x00}, // פ
    {0xC6, 0xCC, 0x78, 0x30, 0x30, 0x30, 0x30, 0x30}, // ץ
    {0x00, 0xC6, 0xCC, 0x78, 0x30, 0x7E, 0xFE, 0x00}, // צ
    {0x7E, 0x7E, 0x60, 0x66, 0x66, 0x26, 0x06, 0x06}, // ק
    {0x00, 0x7E, 0x7E, 0x60, 0x60, 0x60, 0x60, 0x00}, // ר
    {0x00, 0xDB, 0xDB, 0xDB, 0xCF, 0xFF, 0x7F, 0x00}, // ש
    {0x00, 0x7E, 0x7E, 0x66, 0x66, 0x67, 0x67, 0x00}  // ת
};

void pulse(int pin) {
  digitalWrite(pin, HIGH);
  digitalWrite(pin, LOW);
}

void setLatch(int adderss) {
  digitalWrite(ADDERSS_0_PIN, bitRead(adderss, 0));
  digitalWrite(ADDERSS_1_PIN, bitRead(adderss, 1));
  digitalWrite(ADDERSS_2_PIN, bitRead(adderss, 2));
  pulse(ENABLE_PIN);
}

template <size_t N>
void sendBitsData(bool (&bitsArray)[N]) {
  for (int i = N - 1; i >= 0; i--) {
    digitalWrite(DATA_PIN, bitsArray[i]);
    pulse(CLK_PIN);
  }
}

// פונקציה לעדכון כל המסך הפיזי מתוך הזיכרון הנוכחי
void refreshAllDisplay() {
  for (int i = 0; i < 8; i++) {
    sendBitsData(roomOutputs[i]);
    setLatch(i);
  }
}

void setLed(int room, int led) {
  int roomIdx = room - 1;
  int ledIndex = led - 1;
  roomOutputs[roomIdx][ledIndex] = !roomOutputs[roomIdx][ledIndex];
  Serial.println(roomOutputs[roomIdx][ledIndex] == 1 ? "הדלקה" : "כיבוי");
  sendBitsData(roomOutputs[roomIdx]);
  setLatch(roomIdx);
}

// פונקציה שמקבלת מחרוזת UTF-8 מערוץ הטורי ומחלצת את האינדקס של האות בעברית
int getHebrewLetterIndex(String input) {
  if (input.length() < 2) return -1;
  
  // בערוץ הטורי (UTF-8), אותיות בעברית מיוצגות על ידי שני בתים.
  // הצירוף של שניהם נותן לנו ערך ייחודי לכל אות.
  uint8_t byte1 = input[0];
  uint8_t byte2 = input[1];
  
  // אותיות א' עד ת' הרגילות והסופיות נעזרות בטווח הבתים החל מ-0xD790
  if (byte1 == 0xD7) {
    if (byte2 >= 0x90 && byte2 <= 0xAA) {
      return byte2 - 0x90; // מחזיר מספר בין 0 ל-26 המקביל לאינדקס במערך הפונט
    }
  }
  return -1; // לא אות תקנית בעברית
}

// פונקציה שטוענת אות לתוך מערך זיכרון הלדים ומדפיסה פיזית
void displayLetter(int letterIndex) {
  if (letterIndex < 0 || letterIndex >= 27) return;

  for (int row = 0; row < 8; row++) {
    uint8_t rowByte = hebrew_font[letterIndex][row];
    for (int col = 0; col < 8; col++) {
      // חילוץ ביט בודד מתוך הבייט (משמאל לימין) והזרקתו למטריצה שלך
      roomOutputs[row][col] = (rowByte & (1 << (7 - col))) ? 1 : 0;
    }
  }
  
  // דחיפת המערך המעודכן לחומרה
  refreshAllDisplay();
}

void printCurrentCompressedLayout() {
  Serial.print("{");
  for (int row = 0; row < 8; row++) {
    uint8_t rowValue = 0;
    for (int col = 0; col < 8; col++) {
      if (roomOutputs[row][col]) {
        // הדלקת הביט המתאים (משמאל לימין)
        rowValue |= (1 << (7 - col));
      }
    }
    
    // הדפסת הערך בפורמט Hex (לדוגמה 0x42)
    Serial.print("0x");
    if (rowValue < 16) Serial.print("0"); // הוספת אפס מוביל עבור ערכים נמוכים מ-16
    Serial.print(rowValue, HEX);
    
    // הוספת פסיק בין האיברים (פרט לאיבר האחרון)
    if (row < 7) {
      Serial.print(", ");
    }
  }
  Serial.println("}");
}

void setup() {
  Serial.begin(115200);

  pinMode(DATA_PIN, OUTPUT);
  pinMode(CLK_PIN,  OUTPUT);

  pinMode(ENABLE_PIN, OUTPUT);

  pinMode(ADDERSS_0_PIN, OUTPUT);
  pinMode(ADDERSS_1_PIN, OUTPUT);
  pinMode(ADDERSS_2_PIN, OUTPUT);
  
  digitalWrite(ENABLE_PIN, LOW);

  // אתחול המסך
  refreshAllDisplay();

  Serial.println("המערכת מוכנה!");
  Serial.println("1. לשליטה בלד בודד הקלד: חדר.נורה (למשל: 6.5)");
  Serial.println("2. הקלד אות בעברית כדי להציג אותה במטריצה");
  Serial.println("3. לכיבוי כל הלדים בלוח הקלד 0");
  Serial.println("4. להדלקת כל הלדים בלוח הקלד 1");
}

void loop() {
  if (Serial.available() > 0) {
    String inputData = Serial.readStringUntil('\n');
    inputData.trim();
    
    if (inputData == "הדפס" || inputData == "print" || inputData == "הדפסה") {
      printCurrentCompressedLayout();
      return; // סיום הריצה של ה-loop הנוכחי
    }

    if (inputData == "0") {
      for (int row = 0; row < 8; row++) {
        for (int col = 0; col < 8; col++) {
          roomOutputs[row][col] = 0;
        }
      }
      refreshAllDisplay();
      return;
    }

    if (inputData == "1") {
      for (int row = 0; row < 8; row++) {
        for (int col = 0; col < 8; col++) {
          roomOutputs[row][col] = 1;
        }
      }
      refreshAllDisplay();
      return;
    }

    int dotIndex = inputData.indexOf('.');
    
    if (dotIndex != -1) {
      // אפשרות 1: המשתמש הקליד שליטה בלד בודד בפורמט נקודה
      String roomPart = inputData.substring(0, dotIndex);
      String ledPart = inputData.substring(dotIndex + 1);

      int roomNumber = roomPart.toInt();
      int ledNumber = ledPart.toInt();

      if(roomNumber >= 1 && roomNumber <= 8 && ledNumber >= 1 && ledNumber <= 8) {
        Serial.print("חדר-");
        Serial.print(roomNumber);
        Serial.print(", נורה-");
        Serial.print(ledNumber);
        Serial.print(": ");
        setLed(roomNumber, ledNumber);
      } else {
        Serial.println("שגיאה: מספר חדר או נורה חייב להיות בין 1 ל-8");
      }
      
    } else {
      // אפשרות 2: נבדוק אם המשתמש הזין אות בעברית
      int letterIndex = getHebrewLetterIndex(inputData);
      
      if (letterIndex != -1) {
        Serial.print("מציג אות אינדקס: ");
        Serial.println(letterIndex);
        displayLetter(letterIndex);
      } else {
        Serial.println("שגיאה: קלט לא מוכר. השתמש בפורמט 'חדר.נורה' או באות בעברית.");
      }
    }
  }
}