#include <Arduino.h>
#define BUTTON_PIN 10
#define BUTTON_PIN3 9
#define BUTTON_PIN1 11 
#define BUTTON_PIN2 12 

#define SEG_S1 A0
#define SEG_S2 A1
#define SEG_S3 A2
#define SEG_S4 A3

#define SEG_S11 A0
#define SEG_S22 A1
#define SEG_S33 A2
#define SEG_S44 A3

#define SEG_A1 PD2
#define SEG_B1 PD3
#define SEG_C1 PD4
#define SEG_D1 PD5
#define SEG_E1 PD6
#define SEG_F1 PD7
#define SEG_G1 8
#define SEG_DP1 PB1

#define SEG_A2 PD2
#define SEG_B2 PD3
#define SEG_C2 PD4
#define SEG_D2 PD5
#define SEG_E2 6
#define SEG_F2 7
#define SEG_G2 8
#define SEG_DP2 PB1



void displayNumber0(int i) {
  if (i==1){
  digitalWrite(SEG_A1, HIGH);
  digitalWrite(SEG_B1, HIGH);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, HIGH);
  digitalWrite(SEG_E1, HIGH);
  digitalWrite(SEG_F1, HIGH);
  digitalWrite(SEG_G1, LOW);
  digitalWrite(SEG_DP1, LOW);
  }else if(i==2){
  digitalWrite(SEG_A2, HIGH);
  digitalWrite(SEG_B2, HIGH);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, HIGH);
  digitalWrite(SEG_E2, HIGH);
  digitalWrite(SEG_F2, HIGH);
  digitalWrite(SEG_G2, LOW);
  digitalWrite(SEG_DP2, LOW);
  }

}

void displayNumber1(int i) {
  if(i==1){
  digitalWrite(SEG_A1, LOW);
  digitalWrite(SEG_B1, HIGH);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, LOW);
  digitalWrite(SEG_E1, LOW);
  digitalWrite(SEG_F1, LOW);
  digitalWrite(SEG_G1, LOW);
  digitalWrite(SEG_DP1, LOW);
  }else if(i==2){
  digitalWrite(SEG_A2, LOW);
  digitalWrite(SEG_B2, HIGH);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, LOW);
  digitalWrite(SEG_E2, LOW);
  digitalWrite(SEG_F2, LOW);
  digitalWrite(SEG_G2, LOW);
  digitalWrite(SEG_DP2, LOW);
  }
}

void displayNumber2(int i) {
  if(i==1){
  digitalWrite(SEG_A1, HIGH);
  digitalWrite(SEG_B1, HIGH);
  digitalWrite(SEG_C1, LOW);
  digitalWrite(SEG_D1, HIGH);
  digitalWrite(SEG_E1, HIGH);
  digitalWrite(SEG_F1, LOW);
  digitalWrite(SEG_G1, HIGH);
  digitalWrite(SEG_DP1, LOW);
  }else if(i==2){
  digitalWrite(SEG_A2, HIGH);
  digitalWrite(SEG_B2, HIGH);
  digitalWrite(SEG_C2, LOW);
  digitalWrite(SEG_D2, HIGH);
  digitalWrite(SEG_E2, HIGH);
  digitalWrite(SEG_F2, LOW);
  digitalWrite(SEG_G2, HIGH);
  digitalWrite(SEG_DP2, LOW);
  }
}

void displayNumber3(int i) {
  if(i==1){
  digitalWrite(SEG_A1, HIGH);
  digitalWrite(SEG_B1, HIGH);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, HIGH);
  digitalWrite(SEG_E1, LOW);
  digitalWrite(SEG_F1, LOW);
  digitalWrite(SEG_G1, HIGH);
  digitalWrite(SEG_DP1, LOW);
  }else if(i==2){
  digitalWrite(SEG_A2, HIGH);
  digitalWrite(SEG_B2, HIGH);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, HIGH);
  digitalWrite(SEG_E2, LOW);
  digitalWrite(SEG_F2, LOW);
  digitalWrite(SEG_G2, HIGH);
  digitalWrite(SEG_DP2, LOW);
  }
}

void displayNumber4(int i) {
  if(i==1){
  digitalWrite(SEG_A1, LOW);
  digitalWrite(SEG_B1, HIGH);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, LOW);
  digitalWrite(SEG_E1, LOW);
  digitalWrite(SEG_F1, HIGH);
  digitalWrite(SEG_G1, HIGH);
  digitalWrite(SEG_DP1, LOW);

  }else if(i==2){
  digitalWrite(SEG_A2, LOW);
  digitalWrite(SEG_B2, HIGH);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, LOW);
  digitalWrite(SEG_E2, LOW);
  digitalWrite(SEG_F2, HIGH);
  digitalWrite(SEG_G2, HIGH);
  digitalWrite(SEG_DP2, LOW);
  }
}

void displayNumber5(int i) {
if(i==1){
  digitalWrite(SEG_A1, HIGH);
  digitalWrite(SEG_B1, LOW);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, HIGH);
  digitalWrite(SEG_E1, LOW);
  digitalWrite(SEG_F1, HIGH);
  digitalWrite(SEG_G1, HIGH);
  digitalWrite(SEG_DP1, LOW);
}else if(i==2){
  digitalWrite(SEG_A2, HIGH);
  digitalWrite(SEG_B2, LOW);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, HIGH);
  digitalWrite(SEG_E2, LOW);
  digitalWrite(SEG_F2, HIGH);
  digitalWrite(SEG_G2, HIGH);
  digitalWrite(SEG_DP2, LOW);
}
}

void displayNumber6(int i) {
 if(i==1){
  digitalWrite(SEG_A1, HIGH);
  digitalWrite(SEG_B1, LOW);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, HIGH);
  digitalWrite(SEG_E1, HIGH);
  digitalWrite(SEG_F1, HIGH);
  digitalWrite(SEG_G1, HIGH);
  digitalWrite(SEG_DP1, LOW);
 }else if(i==2){
  digitalWrite(SEG_A2, HIGH);
  digitalWrite(SEG_B2, LOW);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, HIGH);
  digitalWrite(SEG_E2, HIGH);
  digitalWrite(SEG_F2, HIGH);
  digitalWrite(SEG_G2, HIGH);
  digitalWrite(SEG_DP2, LOW);
 }
}

void displayNumber7(int i) {
  if(i==1){
  digitalWrite(SEG_A1, HIGH);
  digitalWrite(SEG_B1, HIGH);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, LOW);
  digitalWrite(SEG_E1, LOW);
  digitalWrite(SEG_F1, LOW);
  digitalWrite(SEG_G1, LOW);
  digitalWrite(SEG_DP1, LOW);
  }else if(i==2){
  digitalWrite(SEG_A2, HIGH);
  digitalWrite(SEG_B2, HIGH);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, LOW);
  digitalWrite(SEG_E2, LOW);
  digitalWrite(SEG_F2, LOW);
  digitalWrite(SEG_G2, LOW);
  digitalWrite(SEG_DP2, LOW);
  }
}

void displayNumber8(int i) {
  if(i==1){
  digitalWrite(SEG_A1, HIGH);
  digitalWrite(SEG_B1, HIGH);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, HIGH);
  digitalWrite(SEG_E1, HIGH);
  digitalWrite(SEG_F1, HIGH);
  digitalWrite(SEG_G1, HIGH);
  digitalWrite(SEG_DP1, LOW);
  }else if(i==2){
  digitalWrite(SEG_A2, HIGH);
  digitalWrite(SEG_B2, HIGH);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, HIGH);
  digitalWrite(SEG_E2, HIGH);
  digitalWrite(SEG_F2, HIGH);
  digitalWrite(SEG_G2, HIGH);
  digitalWrite(SEG_DP2, LOW);
  }
}

void displayNumber9(int i) {
  if(i==1){
  digitalWrite(SEG_A1, HIGH);
  digitalWrite(SEG_B1, HIGH);
  digitalWrite(SEG_C1, HIGH);
  digitalWrite(SEG_D1, HIGH);
  digitalWrite(SEG_E1, LOW);
  digitalWrite(SEG_F1, HIGH);
  digitalWrite(SEG_G1, HIGH);
  digitalWrite(SEG_DP1, LOW);
  }else if(i==2){
  digitalWrite(SEG_A2, HIGH);
  digitalWrite(SEG_B2, HIGH);
  digitalWrite(SEG_C2, HIGH);
  digitalWrite(SEG_D2, HIGH);
  digitalWrite(SEG_E2, LOW);
  digitalWrite(SEG_F2, HIGH);
  digitalWrite(SEG_G2, HIGH);
  digitalWrite(SEG_DP2, LOW);
  }
}


void (*displayFunctions[10])(int) = {
  displayNumber0,
  displayNumber1,
  displayNumber2,
  displayNumber3,
  displayNumber4,
  displayNumber5,
  displayNumber6,
  displayNumber7,
  displayNumber8,
  displayNumber9
};

int currentNumber = 0;
unsigned long lastDebounceTime = 0;  // ostatni czas odbicia
unsigned long debounceDelay = 50;    // opóźnienie odbicia
bool lastButtonState = LOW;          // ostatni stan przycisku

//int currentNumber = 0;
int firstNumber = 0;
int secondNumber = 0;
int sum = 0;
int numberToSet = 1;        // 1 dla pierwszej liczby, 2 dla drugiej
int operationMode = 1;      // 1 - dodawanie, 2 - odejmowanie, 3 - mnożenie

  



bool lastButton1State = LOW;
bool lastButton2State = LOW;

void setup() {
    pinMode(BUTTON_PIN, INPUT);
    pinMode(BUTTON_PIN1, INPUT);
    pinMode(BUTTON_PIN2, INPUT);
    pinMode(BUTTON_PIN3, INPUT);
  pinMode(SEG_A1, OUTPUT);
  pinMode(SEG_B1, OUTPUT);
  pinMode(SEG_C1, OUTPUT);
  pinMode(SEG_D1, OUTPUT);
  pinMode(SEG_E1, OUTPUT);
  pinMode(SEG_F1, OUTPUT);
  pinMode(SEG_G1, OUTPUT);

  pinMode(SEG_A2, OUTPUT);
  pinMode(SEG_B2, OUTPUT);
  pinMode(SEG_C2, OUTPUT);
  pinMode(SEG_D2, OUTPUT);
  pinMode(SEG_E2, OUTPUT);
  pinMode(SEG_F2, OUTPUT);
  pinMode(SEG_G2, OUTPUT);

  pinMode(SEG_DP1, OUTPUT);
  pinMode(SEG_DP2, OUTPUT);
  pinMode(SEG_S1, OUTPUT);
  pinMode(SEG_S2, OUTPUT);
  pinMode(SEG_S3, OUTPUT);
  pinMode(SEG_S4, OUTPUT);
  pinMode(SEG_S11, OUTPUT);
  pinMode(SEG_S22, OUTPUT);
  pinMode(SEG_S33, OUTPUT);
  pinMode(SEG_S44, OUTPUT);

  digitalWrite(SEG_S1, HIGH); 
  digitalWrite(SEG_S2, HIGH); // Aktywuj lewy segment
  digitalWrite(SEG_S3, HIGH); 
  digitalWrite(SEG_S4, HIGH); // Aktywuj lewy segment

  digitalWrite(SEG_S11, HIGH); 
 digitalWrite(SEG_S22, HIGH); // Aktywuj lewy segment
  digitalWrite(SEG_S33, HIGH); 
  digitalWrite(SEG_S44, HIGH); // Aktywuj lewy segment

}



void loop() {
    int reading = digitalRead(BUTTON_PIN);  // Odczytaj stan pierwszego przycisku
    int reading1 = digitalRead(BUTTON_PIN1);  // Odczytaj stan drugiego przycisku
    int reading2 = digitalRead(BUTTON_PIN2);  // Odczytaj stan trzeciego przycisku
    int reading3 = digitalRead(BUTTON_PIN3);

    // Obsługa pierwszego przycisku - zmiana aktualnej liczby
    if (reading != lastButtonState && millis() - lastDebounceTime > debounceDelay) {
        lastDebounceTime = millis();
        if (reading == HIGH) {
            currentNumber = (currentNumber + 1) % 10;  // Cykliczne przelączanie między cyframi 0-9
            displayDigit(currentNumber,2);
            delay(250);
        }
    }
    lastButtonState = reading;// stan niski detekcja 
    int suma =0;
    // Obsługa drugiego przycisku - wybór pierwszej lub drugiej liczby oraz wykonanie obliczeń
    if (reading1 != lastButton1State && millis() - lastDebounceTime > debounceDelay) {
        lastDebounceTime = millis();
        if (reading1 == HIGH) {
            if (numberToSet == 1) {
                firstNumber = currentNumber;
                numberToSet = 2;  // Przygotuj do ustawienia drugiej liczby
            } else {
                secondNumber = currentNumber;
                suma = calculateAndDisplay(operationMode,firstNumber,secondNumber);  // Wykonaj obliczenie na podstawie wybranej operacji
                numberToSet = 1;  // Reset do ustawienia pierwszej liczby
            }
            delay(250);
        }
    }
    lastButton1State = reading1;

    // Obsługa trzeciego przycisku - wybór rodzaju operacji
    if (reading2 != lastButton2State && millis() - lastDebounceTime > debounceDelay) {
        lastDebounceTime = millis();
        if (reading2 == HIGH) {
            operationMode = (operationMode % 4) + 1;  // Cykliczne przełączanie operacji: 1-Dodawanie, 2-Odejmowanie, 3-Mnożenie, 4-Dzielenie
            displayDigit(operationMode,2);  // Wyświetl aktualnie wybraną operację
            delay(250);
        }
    }
    lastButton2State = reading2;
     

     displayResult(suma);
}

int calculateAndDisplay(int operationMode,int firstNumber,int secondNumber) {
    switch (operationMode) {
        case 1:
            sum = firstNumber + secondNumber;
            break;
        case 2:
            sum = firstNumber - secondNumber;
            break;
        case 3:
            sum = firstNumber * secondNumber;
            break;
        case 4:  // Dodanie przypadku dzielenia
            sum = secondNumber != 0 ? firstNumber / secondNumber : 0;  // Sprawdź dzielenie przez zero
            break;
    }
     //clearDisplay();

     return sum;
  
 

    // delay(250);
}


void displayLeftDigit(int digit) {
    digitalWrite(SEG_S1, HIGH); 
    digitalWrite(SEG_S2, HIGH); // Aktywuj lewy segment
    digitalWrite(SEG_S4, HIGH); 
    digitalWrite(SEG_S3, LOW); // Aktywuj lewy segment
    displayDigit(digit,1);
 //   digitalWrite(SEG_S4, HIGH); // Deaktywuj lewy segment
}

void displayRightDigit(int digit) {
    digitalWrite(SEG_S11, HIGH); 
    digitalWrite(SEG_S22, HIGH); // Aktywuj lewy segment
    digitalWrite(SEG_S33, HIGH); 
    digitalWrite(SEG_S44, LOW); // Aktywuj prawy segment
    displayDigit(digit,2);
 //   digitalWrite(SEG_S1, HIGH); // Deaktywuj prawy segment
}

void clearDisplay() {

    
    for (int pin = SEG_A1; pin <= SEG_DP1; pin++) {
        digitalWrite(pin, LOW);
    }
    for (int pin = SEG_A2; pin <= SEG_DP2; pin++) {
       digitalWrite(pin, LOW);
   }
}


void displayResult(int value) {
    int leftDigit = value / 10;
    int rightDigit = value % 10;

    for (int i = 0; i < 200; i++) { 
        displayDigit(leftDigit, 1); 
        delay(5); 
        displayDigit(rightDigit, 2); 
        delay(5);
   
    }
}


void displayDigit(int number, int digitIndex) {

   digitalWrite(SEG_S33, digitIndex == 1 ? LOW : HIGH); 
  digitalWrite(SEG_S4, digitIndex == 2 ? LOW : HIGH); 
    displayFunctions[number](1);
}

    




/*
#include <Arduino.h>

#define BUTTON_PIN 10
#define BUTTON_PIN3 9
#define BUTTON_PIN1 11 
#define BUTTON_PIN2 12 

#define SEG_S1 A0
#define SEG_S2 A1
#define SEG_S3 A2
#define SEG_S4 A3

#define SEG_A1 PD2
#define SEG_B1 PD3
#define SEG_C1 PD4
#define SEG_D1 PD5
#define SEG_E1 PD6
#define SEG_F1 PD7
#define SEG_G1 8
#define SEG_DP1 PB1

#define SEG_A2 PD2
#define SEG_B2 PD3
#define SEG_C2 PD4
#define SEG_D2 PD5
#define SEG_E2 6
#define SEG_F2 7
#define SEG_G2 8
#define SEG_DP2 PB1

int digitPins[] = {SEG_S3, SEG_S4}; // Pins for digits
int segmentPins1[] = {SEG_A1, SEG_B1, SEG_C1, SEG_D1, SEG_E1, SEG_F1, SEG_G1, SEG_DP1};
int segmentPins2[] = {SEG_A2, SEG_B2, SEG_C2, SEG_D2, SEG_E2, SEG_F2, SEG_G2, SEG_DP2};

int currentNumber = 0;
int firstNumber = 0;
int secondNumber = 0;
int sum = 0;
int numberToSet = 1;
int operationMode = 1;

unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;
bool lastButtonState = LOW;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(BUTTON_PIN1, INPUT);
  pinMode(BUTTON_PIN2, INPUT);
  pinMode(BUTTON_PIN3, INPUT);

  for (int i = 0; i < 2; i++) {
    pinMode(digitPins[i], OUTPUT);
    digitalWrite(digitPins[i], HIGH); // Common cathode: HIGH = OFF
  }

  for (int i = 0; i < 8; i++) {
    pinMode(segmentPins1[i], OUTPUT);
    digitalWrite(segmentPins1[i], LOW);
    pinMode(segmentPins2[i], OUTPUT);
    digitalWrite(segmentPins2[i], LOW);
  }
}

void loop() {
  readButtons();
  display();
}

void readButtons() {
  int reading = digitalRead(BUTTON_PIN);
  if (reading != lastButtonState && millis() - lastDebounceTime > debounceDelay) {
    lastDebounceTime = millis();
    if (reading == HIGH) {
      currentNumber = (currentNumber + 1) % 10;
    }
  }
  lastButtonState = reading;
  // Handle other buttons similarly
}

void display() {
  static unsigned long lastRefreshTime = 0;
  static int activeDigit = 0;

  if (millis() - lastRefreshTime > 5) {
    digitalWrite(digitPins[activeDigit], HIGH); // Turn off the current digit
    activeDigit = (activeDigit + 1) % 2; // Switch digits
    setSegments((activeDigit == 0 ? firstNumber : secondNumber), activeDigit);
    digitalWrite(digitPins[activeDigit], LOW); // Turn on the new digit
    lastRefreshTime = millis();
  }
}

void setSegments(int num, int digitIndex) {
  static const byte segmentValues[] = {
    0b00111111, 0b00000110, 0b01011011, 0b01001111, 0b01100110,
    0b01101101, 0b01111101, 0b00000111, 0b01111111, 0b01101111
  };

  byte val = segmentValues[num];
  int* segmentPins = (digitIndex == 0) ? segmentPins1 : segmentPins2;

  for (int i = 0; i < 8; i++) {
    digitalWrite(segmentPins[i], (val & (1 << i)) ? HIGH : LOW);
  }
}
*/
/*
#include <Arduino.h>

#define BUTTON_PIN 10
#define BUTTON_PIN1 11 
#define BUTTON_PIN2 12
#define BUTTON_PIN3 9

#define SEG_S3 A2
#define SEG_S4 A3

#define SEG_A1 PD2
#define SEG_B1 PD3
#define SEG_C1 PD4
#define SEG_D1 PD5
#define SEG_E1 PD6
#define SEG_F1 PD7
#define SEG_G1 8
#define SEG_DP1 PB1

int digitPins[] = {SEG_S3, SEG_S4};
int segmentPins1[] = {SEG_A1, SEG_B1, SEG_C1, SEG_D1, SEG_E1, SEG_F1, SEG_G1, SEG_DP1};
int segmentPins2[] = {SEG_A1, SEG_B1, SEG_C1, SEG_D1, SEG_E1, SEG_F1, SEG_G1, SEG_DP1}; // Asumujemy te same piny dla obu cyfr dla uproszczenia

int currentNumber = 0;
int firstNumber = 0, secondNumber = 0;
int sum = 0;
int numberToSet = 1;
int operationMode = 1;

unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;

bool buttonStates[4] = {LOW, LOW, LOW, LOW};

void setup() {
    pinMode(BUTTON_PIN, INPUT);
    pinMode(BUTTON_PIN1, INPUT);
    pinMode(BUTTON_PIN2, INPUT);
    pinMode(BUTTON_PIN3, INPUT);

    for (int i = 0; i < 2; i++) {
        pinMode(digitPins[i], OUTPUT);
        digitalWrite(digitPins[i], HIGH); // Common cathode: HIGH = OFF
    }

    for (int i = 0; i < 8; i++) {
        pinMode(segmentPins1[i], OUTPUT);
        digitalWrite(segmentPins1[i], LOW); // Initially turn off all segments
    }
}

void loop() {
    readButtons();
    display();
}

void readButtons() {
    // Reading each button state and performing debounce check
    updateButtonState(BUTTON_PIN, 0);
    updateButtonState(BUTTON_PIN1, 1);
    updateButtonState(BUTTON_PIN2, 2);
    updateButtonState(BUTTON_PIN3, 3);

    // Actions based on button state changes
    if (buttonStates[0] == HIGH) { // BUTTON_PIN for cycling numbers
        currentNumber = (currentNumber + 1) % 10;
        delay(250); // Simple method to avoid fast cycling
    }

    if (buttonStates[1] == HIGH) { // BUTTON_PIN1 for setting number
        if (numberToSet == 1) {
            firstNumber = currentNumber;
            numberToSet = 2;
        } else {
            secondNumber = currentNumber;
            calculateAndDisplay();
            numberToSet = 1; // Reset to first number after operation
        }
        delay(250);
    }

    if (buttonStates[2] == HIGH) { // BUTTON_PIN2 for changing operation mode
        operationMode = (operationMode % 4) + 1;
        delay(250);
    }

    if (buttonStates[3] == HIGH) { // BUTTON_PIN3 for additional functionality if needed
        // Possible reset or special function
        delay(250);
    }
}

void updateButtonState(int pin, int index) {
    int reading = digitalRead(pin);
    if (reading != buttonStates[index] && (millis() - lastDebounceTime) > debounceDelay) {
        lastDebounceTime = millis();
        buttonStates[index] = reading;
    }
}

void calculateAndDisplay() {
    switch (operationMode) {
        case 1: sum = firstNumber + secondNumber; break;
        case 2: sum = firstNumber - secondNumber; break;
        case 3: sum = firstNumber * secondNumber; break;
        case 4: sum = (secondNumber != 0) ? firstNumber / secondNumber : 0; break;
    }
    display();
}

void display() {
    static unsigned long lastRefreshTime = 0;
    static int activeDigit = 0;

    if (millis() - lastRefreshTime > 5) {
        digitalWrite(digitPins[activeDigit], HIGH);
        activeDigit = (activeDigit + 1) % 2;
        setSegments((activeDigit == 0 ? firstNumber : secondNumber), activeDigit);
        digitalWrite(digitPins[activeDigit], LOW);
        lastRefreshTime = millis();
    }
}

void setSegments(int num, int digitIndex) {
    static const byte segmentValues[] = {
        0b00111111, 0b00000110, 0b01011011, 0b01001111, 0b01100110,
        0b01101101, 0b01111101, 0b00000111, 0b01111111, 0b01101111
    };
    byte val = segmentValues[num];
    int* segmentPins = (digitIndex == 0) ? segmentPins1 : segmentPins2;

    for (int i = 0; i < 8; i++) {
        digitalWrite(segmentPins[i], (val & (1 << i)) ? HIGH : LOW);
    }
}
*/
/*
#include <Arduino.h>

#define BUTTON_PIN_INC 10  // Increase current number
#define BUTTON_PIN_DEC 11  // Decrease current number
#define BUTTON_PIN_SET 12  // Set number and switch mode
#define BUTTON_PIN_OP 9    // Change operation

#define SEG_S1 A0
#define SEG_S2 A1

#define SEG_A PD2
#define SEG_B PD3
#define SEG_C PD4
#define SEG_D PD5
#define SEG_E PD6
#define SEG_F PD7
#define SEG_G 8
#define SEG_DP PB1

int digitPins[] = {SEG_S1, SEG_S2};  // Pins for the two digits
int segmentPins[] = {SEG_A, SEG_B, SEG_C, SEG_D, SEG_E, SEG_F, SEG_G, SEG_DP};  // Segment pins

int currentNumber = 0;  // Currently inputting number
int firstNumber = 0, secondNumber = 0;  // Two numbers for operations
int sum = 0;  // Result of operation
bool settingFirstNumber = true;  // Toggle between setting first and second number

unsigned long lastDebounceTime = 0;  // For debouncing buttons
const unsigned long debounceDelay = 50;  // Debounce threshold in milliseconds

void setup() {
    pinMode(BUTTON_PIN_INC, INPUT);
    pinMode(BUTTON_PIN_DEC, INPUT);
    pinMode(BUTTON_PIN_SET, INPUT);
    pinMode(BUTTON_PIN_OP, INPUT);

    for (int i = 0; i < 2; i++) {
        pinMode(digitPins[i], OUTPUT);
        digitalWrite(digitPins[i], HIGH);  // Turn off digits (common cathode)
    }

    for (int i = 0; i < 8; i++) {
        pinMode(segmentPins[i], OUTPUT);
        digitalWrite(segmentPins[i], LOW);  // Turn off all segments
    }
}

void loop() {
    readButtons();
    display();
}

void readButtons() {
    int reading;
    // Increase current number
    reading = digitalRead(BUTTON_PIN_INC);
    if (reading == HIGH && millis() - lastDebounceTime > debounceDelay) {
        currentNumber = (currentNumber + 1) % 10;
        lastDebounceTime = millis();
    }
    // Decrease current number
    reading = digitalRead(BUTTON_PIN_DEC);
    if (reading == HIGH && millis() - lastDebounceTime > debounceDelay) {
        currentNumber = (currentNumber - 1 + 10) % 10;
        lastDebounceTime = millis();
    }
    // Set the number and switch between first and second number
    reading = digitalRead(BUTTON_PIN_SET);
    if (reading == HIGH && millis() - lastDebounceTime > debounceDelay) {
        if (settingFirstNumber) {
            firstNumber = currentNumber;
            settingFirstNumber = false;  // Now set the second number
        } else {
            secondNumber = currentNumber;
            calculateAndDisplay();  // Calculate the operation
            settingFirstNumber = true;  // Reset to first number after showing result
        }
        currentNumber = 0;  // Reset the current number
        lastDebounceTime = millis();
    }
    // Change operation mode
    reading = digitalRead(BUTTON_PIN_OP);
    if (reading == HIGH && millis() - lastDebounceTime > debounceDelay) {
        sum = (sum % 4) + 1;
        lastDebounceTime = millis();
    }
}

void calculateAndDisplay() {
    switch (sum) {
        case 1: sum = firstNumber + secondNumber; break;
        case 2: sum = firstNumber - secondNumber; break;
        case 3: sum = firstNumber * secondNumber; break;
        case 4: sum = (secondNumber != 0) ? firstNumber / secondNumber : 0; break;  // Avoid division by zero
    }
}

void display() {
    static unsigned long lastRefreshTime = 0;
    static int activeDigit = 0;

    if (millis() - lastRefreshTime > 5) {
        digitalWrite(digitPins[activeDigit], HIGH);
        activeDigit = (activeDigit + 1) % 2;
        setSegments((activeDigit == 0 ? sum / 10 : sum % 10), activeDigit);
        digitalWrite(digitPins[activeDigit], LOW);
        lastRefreshTime = millis();
    }
}

void setSegments(int num, int digitIndex) {
    static const byte segmentValues[] = {
        0b00111111, 0b00000110, 0b01011011, 0b01001111, 0b01100110,
        0b01101101, 0b01111101, 0b00000111, 0b01111111, 0b01101111
    };
    byte val = segmentValues[num];
    int* segmentPins = (digitIndex == 0) ? segmentPins1 : segmentPins2;

    for (int i = 0; i < 8; i++) {
        digitalWrite(segmentPins[i], (val & (1 << i)) ? HIGH : LOW);
    }
}

*/


/*
int digitPins[2] = {SEG_S3, SEG_S44};  // Define pins for each digit

int currentNumber = 0; // Currently selected number for input
int firstNumber = 0;   // First number in the operation
int secondNumber = 0;  // Second number in the operation
int sum = 0;           // Sum or result of the operation
int numberToSet = 1;   // 1 for first number, 2 for second number
int operationMode = 1; // 1 - addition, 2 - subtraction, 3 - multiplication, 4 - division

unsigned long lastDebounceTime = 0; // To handle debouncing
bool lastButtonState = LOW;         // Last state of the button
bool lastButton1State = LOW;        // Last state of the first button
bool lastButton2State = LOW;        // Last state of the second button
bool lastButton3State = LOW;        // Last state of the third button

void setup() {
    pinMode(BUTTON_PIN, INPUT);
    pinMode(BUTTON_PIN1, INPUT);
    pinMode(BUTTON_PIN2, INPUT);
    pinMode(BUTTON_PIN3, INPUT);

    pinMode(SEG_A1, OUTPUT);
    pinMode(SEG_B1, OUTPUT);
    // Continue setting pinMode for all segment pins

    digitalWrite(SEG_S1, HIGH);
    digitalWrite(SEG_S2, HIGH);
    digitalWrite(SEG_S3, HIGH);
    digitalWrite(SEG_S4, HIGH);

    digitalWrite(SEG_S11, HIGH);
    digitalWrite(SEG_S22, HIGH);
    digitalWrite(SEG_S33, HIGH);
    digitalWrite(SEG_S44, HIGH);
}

void loop() {
    int reading = digitalRead(BUTTON_PIN);
    int reading1 = digitalRead(BUTTON_PIN1);
    int reading2 = digitalRead(BUTTON_PIN2);
    int reading3 = digitalRead(BUTTON_PIN3);

    if ((millis() - lastDebounceTime) > 50) {
        // Button handling logic
        // Includes debouncing checks and updates to `currentNumber`, `firstNumber`, `secondNumber`, `operationMode`
        display(); // Call display function periodically
    }
}

void display() {
    static unsigned long lastRefreshTime = 0;
    static int activeDigit = 0;
    static bool displayingResult = false;

    if (millis() - lastRefreshTime > 5) {
        if (!displayingResult) {
            displayDigit((activeDigit == 0 ? firstNumber : secondNumber), activeDigit);
        } else {
            int leftDigit = sum / 10;
            int rightDigit = sum % 10;
            displayDigit((activeDigit == 0 ? leftDigit : rightDigit), activeDigit);
        }
        activeDigit = (activeDigit + 1) % 2;
        lastRefreshTime = millis();
    }
}

void displayDigit(int number, int i) {
    digitalWrite(digitPins[(i == 0 ? 1 : 0)], HIGH);  // Turn off the previous digit
    displayDigit[number](i + 1);  // Update segments for the current number
    digitalWrite(digitPins[i], LOW);  // Turn on the current digit
}

void clearDisplay() {
    // Turn off all segments
    for (int pin = SEG_A1; pin <= SEG_DP2; pin++) {
        digitalWrite(pin, LOW);
    }
}

void calculateAndDisplay() {
    switch (operationMode) {
        case 1: sum = firstNumber + secondNumber; break;
        case 2: sum = firstNumber - secondNumber; break;
        case 3: sum = firstNumber * secondNumber; break;
        case 4: sum = (secondNumber != 0) ? (firstNumber / secondNumber) : 0; break;  // Prevent division by zero
    }
    displayingResult = true;
    displaySum(sum);  // Optional, if you want a separate function to handle sum display
}

void displaySum(int sum){
  right = sum%10;
  left=sum/10;
     digitalWrite(digitPins[(i == 0 ? 1 : 0)], HIGH);  // Turn off the previous digit
    displayDigit[number](i + 1);  // Update segments for the current number
    digitalWrite(digitPins[i], LOW);  // Turn on the current digit
}
*/