#include <Arduino.h>
#define BUTTON_PIN1 10
#define BUTTON_PIN2 11 
#define BUTTON_PIN3 12
#define BUTTON_PIN4 13  

#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 6
#define SEG_F1 7
#define SEG_G1 8
#define SEG_DP 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_A3 PD2
#define SEG_B3 PD3
#define SEG_C3 PD4
#define SEG_D3 PD5
#define SEG_E3 6
#define SEG_F3 7
#define SEG_G3 8

#define SEG_A4 PD2
#define SEG_B4 PD3
#define SEG_C4 PD4
#define SEG_D4 PD5
#define SEG_E4 6
#define SEG_F4 7
#define SEG_G4 8
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_DP, 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_DP, LOW);
  }else if(i==3){
  digitalWrite(SEG_A3, HIGH);
  digitalWrite(SEG_B3, HIGH);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, HIGH);
  digitalWrite(SEG_E3, HIGH);
  digitalWrite(SEG_F3, HIGH);
  digitalWrite(SEG_G3, LOW);
  digitalWrite(SEG_DP, LOW);
  }
  else if(i==4){
  digitalWrite(SEG_A4, HIGH);
  digitalWrite(SEG_B4, HIGH);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, HIGH);
  digitalWrite(SEG_E4, HIGH);
  digitalWrite(SEG_F4, HIGH);
  digitalWrite(SEG_G4, LOW);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
  }else if(i==3){
  digitalWrite(SEG_A3, LOW);
  digitalWrite(SEG_B3, HIGH);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, LOW);
  digitalWrite(SEG_E3, LOW);
  digitalWrite(SEG_F3, LOW);
  digitalWrite(SEG_G3, LOW);
  digitalWrite(SEG_DP, LOW);
  }else if(i==4){
  digitalWrite(SEG_A4, LOW);
  digitalWrite(SEG_B4, HIGH);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, LOW);
  digitalWrite(SEG_E4, LOW);
  digitalWrite(SEG_F4, LOW);
  digitalWrite(SEG_G4, LOW);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
  }else if(i==3){
  digitalWrite(SEG_A3, HIGH);
  digitalWrite(SEG_B3, HIGH);
  digitalWrite(SEG_C3, LOW);
  digitalWrite(SEG_D3, HIGH);
  digitalWrite(SEG_E3, HIGH);
  digitalWrite(SEG_F3, LOW);
  digitalWrite(SEG_G3, HIGH);
  digitalWrite(SEG_DP, LOW);
  }else if(i==4){
  digitalWrite(SEG_A4, HIGH);
  digitalWrite(SEG_B4, HIGH);
  digitalWrite(SEG_C4, LOW);
  digitalWrite(SEG_D4, HIGH);
  digitalWrite(SEG_E4, HIGH);
  digitalWrite(SEG_F4, LOW);
  digitalWrite(SEG_G4, HIGH);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
  }else if(i==3){
  digitalWrite(SEG_A3, HIGH);
  digitalWrite(SEG_B3, HIGH);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, HIGH);
  digitalWrite(SEG_E3, LOW);
  digitalWrite(SEG_F3, LOW);
  digitalWrite(SEG_G3, HIGH);
  digitalWrite(SEG_DP, LOW);
  }else if(i==4){
  digitalWrite(SEG_A4, HIGH);
  digitalWrite(SEG_B4, HIGH);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, HIGH);
  digitalWrite(SEG_E4, LOW);
  digitalWrite(SEG_F4, LOW);
  digitalWrite(SEG_G4, HIGH);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
  }else if(i==3){
  digitalWrite(SEG_A3, LOW);
  digitalWrite(SEG_B3, HIGH);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, LOW);
  digitalWrite(SEG_E3, LOW);
  digitalWrite(SEG_F3, HIGH);
  digitalWrite(SEG_G3, HIGH);
  digitalWrite(SEG_DP, LOW);
  }else if(i==4){
  digitalWrite(SEG_A4, LOW);
  digitalWrite(SEG_B4, HIGH);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, LOW);
  digitalWrite(SEG_E4, LOW);
  digitalWrite(SEG_F4, HIGH);
  digitalWrite(SEG_G4, HIGH);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
}else if(i==3){
  digitalWrite(SEG_A3, HIGH);
  digitalWrite(SEG_B3, LOW);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, HIGH);
  digitalWrite(SEG_E3, LOW);
  digitalWrite(SEG_F3, HIGH);
  digitalWrite(SEG_G3, HIGH);
  digitalWrite(SEG_DP, LOW);
}else if(i==4){
  digitalWrite(SEG_A4, HIGH);
  digitalWrite(SEG_B4, LOW);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, HIGH);
  digitalWrite(SEG_E4, LOW);
  digitalWrite(SEG_F4, HIGH);
  digitalWrite(SEG_G4, HIGH);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
 }else if(i==3){
  digitalWrite(SEG_A3, HIGH);
  digitalWrite(SEG_B3, LOW);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, HIGH);
  digitalWrite(SEG_E3, HIGH);
  digitalWrite(SEG_F3, HIGH);
  digitalWrite(SEG_G3, HIGH);
  digitalWrite(SEG_DP, LOW);
 }else if(i==4){
  digitalWrite(SEG_A4, HIGH);
  digitalWrite(SEG_B4, LOW);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, HIGH);
  digitalWrite(SEG_E4, HIGH);
  digitalWrite(SEG_F4, HIGH);
  digitalWrite(SEG_G4, HIGH);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
  }else if(i==3){
  digitalWrite(SEG_A3, HIGH);
  digitalWrite(SEG_B3, HIGH);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, LOW);
  digitalWrite(SEG_E3, LOW);
  digitalWrite(SEG_F3, LOW);
  digitalWrite(SEG_G3, LOW);
  digitalWrite(SEG_DP, LOW);
  }else if(i==4){
  digitalWrite(SEG_A4, HIGH);
  digitalWrite(SEG_B4, HIGH);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, LOW);
  digitalWrite(SEG_E4, LOW);
  digitalWrite(SEG_F4, LOW);
  digitalWrite(SEG_G4, LOW);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
  }else if(i==3){
  digitalWrite(SEG_A3, HIGH);
  digitalWrite(SEG_B3, HIGH);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, HIGH);
  digitalWrite(SEG_E3, HIGH);
  digitalWrite(SEG_F3, HIGH);
  digitalWrite(SEG_G3, HIGH);
  digitalWrite(SEG_DP, LOW);
  }else if(i==4){
  digitalWrite(SEG_A4, HIGH);
  digitalWrite(SEG_B4, HIGH);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, HIGH);
  digitalWrite(SEG_E4, HIGH);
  digitalWrite(SEG_F4, HIGH);
  digitalWrite(SEG_G4, HIGH);
  digitalWrite(SEG_DP, 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_DP, 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_DP, LOW);
  }else if(i==3){
  digitalWrite(SEG_A3, HIGH);
  digitalWrite(SEG_B3, HIGH);
  digitalWrite(SEG_C3, HIGH);
  digitalWrite(SEG_D3, HIGH);
  digitalWrite(SEG_E3, LOW);
  digitalWrite(SEG_F3, HIGH);
  digitalWrite(SEG_G3, HIGH);
  digitalWrite(SEG_DP, LOW);
  }else if(i==4){
  digitalWrite(SEG_A4, HIGH);
  digitalWrite(SEG_B4, HIGH);
  digitalWrite(SEG_C4, HIGH);
  digitalWrite(SEG_D4, HIGH);
  digitalWrite(SEG_E4, LOW);
  digitalWrite(SEG_F4, HIGH);
  digitalWrite(SEG_G4, HIGH);
  digitalWrite(SEG_DP, LOW);
  }
}
//int i;
/*void (*displayFunctions[10])(int i);
void displayNumber1(i);
void displayNumber2(i);
void displayNumber3(i);
void displayNumber4(i);
void displayNumber5(i);
void displayNumber6(i);
void displayNumber7(i);
void displayNumber8(i);
void displayNumber9(i);
void displayNumber0(i);
*/
void (*displayFunctions[10])(int) = {
  displayNumber0,
  displayNumber1,
  displayNumber2,
  displayNumber3,
  displayNumber4,
  displayNumber5,
  displayNumber6,
  displayNumber7,
  displayNumber8,
  displayNumber9
};
//int currentNumber = 0;
unsigned long lastDebounceTime1 = 0;
unsigned long lastDebounceTime2 = 0;  // ostatni czas odbicia
unsigned long debounceDelay = 50;    // opóźnienie odbicia
bool lastButtonState = LOW;          // ostatni stan przycisku
int currentNumber1 = 0;
int currentNumber2 = 0;
//int number=0; 
//int out3=0; int out4=0; 
//int reading3=0; int reading4=0;

void setup() {
  pinMode(BUTTON_PIN1, INPUT);
  pinMode(BUTTON_PIN2, INPUT);
  pinMode(BUTTON_PIN3, INPUT);
  pinMode(BUTTON_PIN4, 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_A3, OUTPUT);
  pinMode(SEG_B3, OUTPUT);
  pinMode(SEG_C3, OUTPUT);
  pinMode(SEG_D3, OUTPUT);
  pinMode(SEG_E3, OUTPUT);
  pinMode(SEG_F3, OUTPUT);
  pinMode(SEG_G3, OUTPUT);

  
  pinMode(SEG_A4, OUTPUT);
  pinMode(SEG_B4, OUTPUT);
  pinMode(SEG_C4, OUTPUT);
  pinMode(SEG_D4, OUTPUT);
  pinMode(SEG_E4, OUTPUT);
  pinMode(SEG_F4, OUTPUT);
  pinMode(SEG_G4, OUTPUT);

  pinMode(SEG_DP, OUTPUT);

  pinMode(SEG_S1, OUTPUT);
  pinMode(SEG_S2, OUTPUT);
  pinMode(SEG_S3, OUTPUT);
  pinMode(SEG_S4, OUTPUT);
 /* displayFunctions[0] = displayNumber0(int i);
  displayFunctions[1] = displayNumber1(i);
  displayFunctions[2] = displayNumber2(i);
  displayFunctions[3] = displayNumber3(i);
  displayFunctions[4] = displayNumber4(i);
  displayFunctions[5] = displayNumber5(i);
  displayFunctions[6] = displayNumber6(i);
  displayFunctions[7] = displayNumber7(i);
  displayFunctions[8] = displayNumber8(i);
  displayFunctions[9] = displayNumber9(i);*/
}


void loop() {
  int counter1=1;int counter2=1;
  int reading1 = digitalRead(BUTTON_PIN1);
  int reading2 = digitalRead(BUTTON_PIN2);
  int reading3 = digitalRead(BUTTON_PIN3);
  int reading4 = digitalRead(BUTTON_PIN4);
  //Serial.println(reading1);
  
  // Jeśli stan przycisku się zmienił i przycisk jest naciśnięty
  if (reading1 != lastButtonState) {
     Serial.println(reading2);
    lastDebounceTime1 = millis();
  }
  if (reading2 != lastButtonState) {
    lastDebounceTime2 = millis();
  }
  
  //if ((millis() - lastDebounceTime1) > debounceDelay) {
     //Serial.println(reading1);
    // jeśli przycisk jest naciśnięty
    if (reading1 == HIGH) {
     // Serial.println("ggh");
      currentNumber1 = (currentNumber1 + 1) % 10;  // Zwiększ liczbę i zresetuj do 0 po 9
      display1Number();
      delay(250); // Opóźnienie dla lepszego odczytu
    }
 // }
 // if ((millis() - lastDebounceTime2) > debounceDelay) {
    if (reading2 == HIGH) {
      currentNumber2 = (currentNumber2 + 1) % 10;  // Zwiększ liczbę i zresetuj do 0 po 9
      display2Number();
      delay(250); // Opóźnienie dla lepszego odczytu
    }
 // }
 // int number =0;
 // lastButtonState = reading;

/*int bramka=0; int cnum1=0; int cnum2=0; int outcome;
 if(reading3 ==HIGH || reading4 ==HIGH){
  int outcome = operations(currentNumber2, currentNumber1,reading3, reading4,reading1,reading2, counter1, counter2);
  //Serial.println(outcome);
   cnum1+=currentNumber1;  cnum2+=currentNumber2;
  bramka++;
 }
  if((reading1==HIGH || reading2==HIGH)&&bramka>0){
  if(reading1 ==HIGH){
    counter1++;
  }else if(reading2==HIGH){
      counter2++;
    }
    int out2 = operations(cnum2, cnum1,reading3, reading4,reading1,reading2, counter1, counter2);
    displayOperationResults(out2);
  }else{
    displayOperationResults(outcome);
  }*/
   if(reading3 ==HIGH || reading4 ==HIGH){
  int outcome = operations(currentNumber2, currentNumber1,reading3, reading4,reading1,reading2, counter1, counter2);
  displayOperationResults(outcome);
   }
 }
 //displayOperationResults(out2);


void display1Number() {
  digitalWrite(SEG_S1, LOW);  // Aktywuj tylko pierwszy segment
  digitalWrite(SEG_S2, HIGH);
  digitalWrite(SEG_S3, HIGH);
  digitalWrite(SEG_S4, HIGH);
  
  displayFunctions[currentNumber1](1);  // Wywołaj funkcję wyświetlającą cyfrę
  
  // Czyszczenie wszystkich segmentów przed następnym cyklem
  for (int pin = SEG_A1; pin <= SEG_DP; pin++) {
    digitalWrite(pin, LOW);
  }
}

void display2Number() {
  Serial.print("kociaki");
  digitalWrite(SEG_S1, HIGH);  // Aktywuj tylko pierwszy segment
  digitalWrite(SEG_S2, LOW);
  digitalWrite(SEG_S3, HIGH);
  digitalWrite(SEG_S4, HIGH);
  
  displayFunctions[currentNumber2](2);  // Wywołaj funkcję wyświetlającą cyfrę
  
  // Czyszczenie wszystkich segmentów przed następnym cyklem
  for (int pin = SEG_A2; pin <= SEG_DP; pin++) {
    digitalWrite(pin, LOW);
  }
}

 int operations(int currentNumber2, int currentNumber1,int reading3,int reading4, int reading1, int reading2,int counter1, int counter2){
  int number;
 // if(reading1==HIGH){
 /*   counter1++;
  }
  if(reading2==HIGH){
    counter2++;
  }
  Serial.println(counter1);*/
  if(reading3 == HIGH && counter1==1){
    number = currentNumber1 + currentNumber2;
  }else if(reading4 == HIGH && counter2==1){
    number = currentNumber1 - currentNumber2;
  }else if(reading3 == HIGH && counter1>1){
    number = currentNumber1*currentNumber2;
  }else if(reading4 == HIGH && counter2>1){
    number = currentNumber1/currentNumber2;
  }
  return number;
 }

void displayOperationResults(int n){
  // Serial.print(n);
 int out4=0;
 int out3=0;
 //Serial.println(out4);
    out4 += n%10;
    n /=10;
     out3 += n;
     Serial.println(out4);
 // Serial.print(out4);
  //Serial.println("kociaki");
 // Serial.println(out4);
 // Serial.println(out3);
  digitalWrite(SEG_S1, HIGH);  // Aktywuj tylko pierwszy segment
  digitalWrite(SEG_S2, HIGH);
  digitalWrite(SEG_S3, LOW);
  digitalWrite(SEG_S4, HIGH);
  displayFunctions[out3](3);
  delay(250);
 // digitalWrite(SEG_S1, HIGH);  // Aktywuj tylko pierwszy segment
 // digitalWrite(SEG_S2, HIGH);
 // digitalWrite(SEG_S3, HIGH);
  digitalWrite(SEG_S4, LOW);
  displayFunctions[out4](4);
  delay(250);
    // Czyszczenie wszystkich segmentów przed następnym cyklem
 // for (int pin = SEG_A3; pin <= SEG_DP; pin++) {
 //   digitalWrite(pin, LOW);
 // }
 // for (int pin = SEG_A4; pin <= SEG_DP; pin++) {
 //   digitalWrite(pin, LOW);
 // }

}

/*
#include <Arduino.h>

#define BUTTON_PIN1 10  // Przycisk zmiany liczby
#define BUTTON_PIN2 11  // Przycisk zmiany operacji i obliczania wyniku

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

#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 PB0
#define SEG_DP PB1

void displayNumber(int num) {
  // Wszystkie segmenty wyłączone
  digitalWrite(SEG_A, LOW);
  digitalWrite(SEG_B, LOW);
  digitalWrite(SEG_C, LOW);
  digitalWrite(SEG_D, LOW);
  digitalWrite(SEG_E, LOW);
  digitalWrite(SEG_F, LOW);
  digitalWrite(SEG_G, LOW);
  digitalWrite(SEG_DP, LOW);

  // Sterowanie segmentami na podstawie wartości num
  switch(num) {
    case 0:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      digitalWrite(SEG_D, HIGH);
      digitalWrite(SEG_E, HIGH);
      digitalWrite(SEG_F, HIGH);
      break;
    case 1:
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      break;
    case 2:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_D, HIGH);
      digitalWrite(SEG_E, HIGH);
      digitalWrite(SEG_G, HIGH);
      break;
    case 3:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      digitalWrite(SEG_D, HIGH);
      digitalWrite(SEG_G, HIGH);
      break;
    case 4:
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      digitalWrite(SEG_F, HIGH);
      digitalWrite(SEG_G, HIGH);
      break;
    case 5:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_C, HIGH);
      digitalWrite(SEG_D, HIGH);
      digitalWrite(SEG_F, HIGH);
      digitalWrite(SEG_G, HIGH);
      break;
    case 6:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_C, HIGH);
      digitalWrite(SEG_D, HIGH);
      digitalWrite(SEG_E, HIGH);
      digitalWrite(SEG_F, HIGH);
      digitalWrite(SEG_G, HIGH);
      break;
    case 7:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      break;
    case 8:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      digitalWrite(SEG_D, HIGH);
      digitalWrite(SEG_E, HIGH);
      digitalWrite(SEG_F, HIGH);
      digitalWrite(SEG_G, HIGH);
      break;
    case 9:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      digitalWrite(SEG_D, HIGH);
      digitalWrite(SEG_F, HIGH);
      digitalWrite(SEG_G, HIGH);
      break;
  }
}

// Zmienne globalne do przechowywania danych
int currentNumber = 0;  // Aktualnie wprowadzana liczba
int firstNumber = 0;    // Pierwsza liczba
int result = 0;         // Wynik
char operation = '+';   // Rodzaj operacji
bool enteringSecondNumber = false;  // Czy wprowadzamy drugą liczbę

unsigned long lastDebounceTime = 0;  // ostatni czas odbicia
unsigned long debounceDelay = 50;    // opóźnienie odbicia
int lastButtonState1 = LOW;          // ostatni stan przycisku 1
int lastButtonState2 = LOW;          // ostatni stan przycisku 2

void setup() {
  pinMode(BUTTON_PIN1, INPUT);
  pinMode(BUTTON_PIN2, INPUT);
  pinMode(SEG_A, OUTPUT);
  pinMode(SEG_B, OUTPUT);
  pinMode(SEG_C, OUTPUT);
  pinMode(SEG_D, OUTPUT);
  pinMode(SEG_E, OUTPUT);
  pinMode(SEG_F, OUTPUT);
  pinMode(SEG_G, OUTPUT);
  pinMode(SEG_DP, OUTPUT);
  pinMode(SEG_S1, OUTPUT);
  pinMode(SEG_S2, OUTPUT);
  pinMode(SEG_S3, OUTPUT);
  pinMode(SEG_S4, OUTPUT);
}

void loop() {
  int reading1 = digitalRead(BUTTON_PIN1);
  int reading2 = digitalRead(BUTTON_PIN2);

  if (reading1 != lastButtonState1) {
    if (reading1 == HIGH) {
      currentNumber = (currentNumber + 1) % 10;
      displayNumber(currentNumber);
      lastDebounceTime = millis();
    }
  }

  if (reading2 != lastButtonState2 && (millis() - lastDebounceTime) > debounceDelay) {
    if (reading2 == HIGH) {
      if (!enteringSecondNumber) {
        firstNumber = currentNumber;
        enteringSecondNumber = true;
        currentNumber = 0;
        operation = (operation == '+') ? '-' : '+';
      } else {
        if (operation == '+') {
          result = firstNumber + currentNumber;
        } else {
          result = firstNumber - currentNumber;
        }
        displayNumber(result % 10);  // Wyświetl tylko ostatnią cyfrę wyniku
        firstNumber = result;  // Umożliwia dalsze obliczenia
        currentNumber = 0;
        enteringSecondNumber = false;
      }
      lastDebounceTime = millis();
    }
  }

  lastButtonState1 = reading1;
  lastButtonState2 = reading2;
}
*/
/*

#include <Arduino.h>

// Przyciski
#define BUTTON_PIN_INCREASE 10
#define BUTTON_PIN_CONFIRM 11

// Wyświetlacze
#define SEG_S1 A0
#define SEG_S2 A1
#define SEG_S3 A2
#define SEG_S4 A3

// Segmenty
#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 PB0
#define SEG_DP PB1

void displayNumber(int num, int display);
void displayResult(int result);

int number1 = 0, number2 = 0;  // Cyfry do obliczeń
int resultAdd, resultSub, resultMul, resultDiv;  // Wyniki różnych operacji
int currentMode = 0;  // Aktualny tryb: 0-4, gdzie 0 i 1 to wprowadzanie cyfr, 2-5 to wyświetlanie wyników

unsigned long lastDebounceTime = 0;  // Ostatni czas "odbicia"
unsigned long debounceDelay = 50;    // Opóźnienie odbicia

void setup() {
  pinMode(BUTTON_PIN_INCREASE, INPUT);
  pinMode(BUTTON_PIN_CONFIRM, INPUT);
  pinMode(SEG_A, OUTPUT);
  pinMode(SEG_B, OUTPUT);
  pinMode(SEG_C, OUTPUT);
  pinMode(SEG_D, OUTPUT);
  pinMode(SEG_E, OUTPUT);
  pinMode(SEG_F, OUTPUT);
  pinMode(SEG_G, OUTPUT);
  pinMode(SEG_DP, OUTPUT);
  pinMode(SEG_S1, OUTPUT);
  pinMode(SEG_S2, OUTPUT);
  pinMode(SEG_S3, OUTPUT);
  pinMode(SEG_S4, OUTPUT);
}

void loop() {
  int readingIncrease = digitalRead(BUTTON_PIN_INCREASE);
  int readingConfirm = digitalRead(BUTTON_PIN_CONFIRM);

  if (millis() - lastDebounceTime > debounceDelay) {
    // Zmiana liczby lub przełączanie między trybami
    if (readingIncrease == HIGH) {
      if (currentMode <= 1) {  // Wprowadzanie cyfr
        if (currentMode == 0) {
          number1 = (number1 + 1) % 10;  // Cyfry od 0 do 9
          displayNumber(number1, 1);
        } else if (currentMode == 1) {
          number2 = (number2 + 1) % 10;
          displayNumber(number2, 2);
        }
      } else {  // Przełączanie wyników
        currentMode = (currentMode + 1) % 6;  // Przewijanie między różnymi wynikami
        displayResult(currentMode);
      }
      lastDebounceTime = millis();
    }

    // Potwierdzenie i obliczenia
    if (readingConfirm == HIGH) {
      if (currentMode == 1) {  // Po wprowadzeniu drugiej liczby wykonujemy obliczenia
        resultAdd = number1 + number2;
        resultSub = number1 - number2;
        resultMul = number1 * number2;
        if (number2 != 0) resultDiv = number1 / number2;
        else resultDiv = 0;  // Unikamy dzielenia przez zero
        currentMode = 2;  // Przechodzimy do trybu wyświetlania wyników
        displayResult(currentMode);
      }
      lastDebounceTime = millis();
    }
  }
}

void displayNumber(int num, int display) {
  // Aktywacja odpowiedniego wyświetlacza
  digitalWrite(SEG_S1, display == 1 ? LOW : HIGH);
  digitalWrite(SEG_S2, display == 2 ? LOW : HIGH);
  // Zresetowanie segmentów
  digitalWrite(SEG_A, LOW);
  digitalWrite(SEG_B, LOW);
  digitalWrite(SEG_C, LOW);
  digitalWrite(SEG_D, LOW);
  digitalWrite(SEG_E, LOW);
  digitalWrite(SEG_F, LOW);
  digitalWrite(SEG_G, LOW);
  digitalWrite(SEG_DP, LOW);

  // Sterowanie segmentami na podstawie wartości num
  switch (num) {
    case 0:
      digitalWrite(SEG_A, HIGH);
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      digitalWrite(SEG_D, HIGH);
      digitalWrite(SEG_E, HIGH);
      digitalWrite(SEG_F, HIGH);
      break;
    case 1:
      digitalWrite(SEG_B, HIGH);
      digitalWrite(SEG_C, HIGH);
      break;
    // Dodać pozostałe cyfry według schematu użytego wcześniej
  }
}

void displayResult(int result) {
  switch (result) {
    case 2:
      displayNumber(resultAdd, 1);
      break;
    case 3:
      displayNumber(resultSub, 1);
      break;
    case 4:
      displayNumber(resultMul, 1);
      break;
    case 5:
      displayNumber(resultDiv, 1);
      break;
  }
}
*/

/*#include <Arduino.h>

// Definicje pinów dla segmentów 7-segmentowego wyświetlacza
const int segmentPins[] = {2, 3, 4, 5, 6, 7, 8}; // a, b, c, d, e, f, g
const int dpPin = 9; // DP (decimal point)

// Definicje pinów dla wspólnych katod (CC)
const int ccPins[] = {10, 11, 12, 13}; // CC1, CC2, CC3, CC4

// Definicje pinów dla switchy
const int switchPins[] = {A0, A1, A2, A3};

// Zmienne globalne
char input[17] = "";
char operation = '\0';
int num1 = 0, num2 = 0, result = 0;
int currentDigit = 0;
volatile int switchState[4] = {HIGH, HIGH, HIGH, HIGH};

// Mapowanie cyfr na segmenty
const byte digitToSegment[] = {
  B00111111, // 0
  B00000110, // 1
  B01011011, // 2
  B01001111, // 3
  B01100110, // 4
  B01101101, // 5
  B01111101, // 6
  B00000111, // 7
  B01111111, // 8
  B01101111  // 9
};

// Funkcja do wyświetlania cyfry na wybranym segmencie
void displayDigit(int digit, int position) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(segmentPins[i], (digitToSegment[digit] >> i) & 0x01);
  }
  digitalWrite(dpPin, LOW); // Wyłączenie kropki dziesiętnej
  digitalWrite(ccPins[position], LOW);
  delay(5); // Zwiększenie opóźnienia, aby zapewnić widoczność
  digitalWrite(ccPins[position], HIGH);
}

// Funkcja do wyświetlania liczby na 4-cyfrowym wyświetlaczu
void displayNumber(int number) {
  int num = number;
  for (int i = 0; i < 4; i++) {
    int digit = num % 10;
    displayDigit(digit, 3 - i); // Wyświetlanie od prawej do lewej
    num /= 10;
  }
}

// Funkcja do odczytywania wejścia z klawiatury (switchy)
char readKeypad() {
  for (int i = 0; i < 4; i++) {
    if (digitalRead(switchPins[i]) == LOW) {
      delay(50); // Debounce
      if (digitalRead(switchPins[i]) == LOW) {
        while (digitalRead(switchPins[i]) == LOW); // Czekaj na zwolnienie switcha
        switch (i) {
          case 0: return '1'; // Switch 1: cyfra 1
          case 1: return '2'; // Switch 2: cyfra 2
          case 2: return '3'; // Switch 3: cyfra 3
          case 3: return '+'; // Switch 4: operator +
        }
      }
    }
  }
  return '\0'; // Brak wciśniętego klawisza
}

void setup() {
  // Inicjalizacja pinów segmentów jako wyjścia
  for (int i = 0; i < 7; i++) {
    pinMode(segmentPins[i], OUTPUT);
  }
  pinMode(dpPin, OUTPUT);

  // Inicjalizacja pinów wspólnych katod jako wyjścia
  for (int i = 0; i < 4; i++) {
    pinMode(ccPins[i], OUTPUT);
    digitalWrite(ccPins[i], HIGH); // Wyłączenie wszystkich katod na start
  }

  // Inicjalizacja pinów switchy jako wejścia
  for (int i = 0; i < 4; i++) {
    pinMode(switchPins[i], INPUT_PULLUP);
  }

  // Inicjalizacja komunikacji szeregowej do debugowania
  Serial.begin(9600);
}

void loop() {
  char key = readKeypad();
  if (key != '\0') {
    if (isdigit(key)) {
      strncat(input, &key, 1);
      int num = atoi(input);
      displayNumber(num);
    } else if (key == '+') {
      if (strlen(input) > 0) {
        num1 = atoi(input);
        input[0] = '\0';
        operation = '+';
      }
    } else if (key == '=') {
      if (strlen(input) > 0) {
        num2 = atoi(input);
        if (operation == '+') {
          result = num1 + num2;
        }
        displayNumber(result);
        num1 = result;
        input[0] = '\0';
        operation = '\0';
      }
    }
  }
  
  // Aktualizowanie wyświetlania cyfr w pętli
  for (int i = 0; i < 4; i++) {
    displayNumber(result);
  }
}
*/
/*
#include <Arduino.h>

// Definicje pinów dla segmentów 7-segmentowego wyświetlacza
const int segmentPins[] = {2, 3, 4, 5, 6, 7, 8}; // a, b, c, d, e, f, g
const int dpPin = 9; // DP (decimal point)

// Definicje pinów dla wspólnych katod (CC)
//const int ccPins[] = {10, 11, 12, 13}; // CC1, CC2, CC3, CC4
const int ccPins[] = {A0, A1, A2, A3};

// Definicje pinów dla switchy
//const int switchPins[] = {A0, A1, A2, A3};
const int switchPins[] = {10, 11, 12, 13};

// Zmienne globalne
char input[17] = "";
char operation = '\0';
int num1 = 0, num2 = 0, result = 0;
int currentDigit = 0;
volatile int switchState[4] = {LOW, LOW, LOW, LOW};

// Mapowanie cyfr na segmenty
const byte digitToSegment[] = {
  B00111111, // 0
  B00000110, // 1
  B01011011, // 2
  B01001111, // 3
  B01100110, // 4
  B01101101, // 5
  B01111101, // 6
  B00000111, // 7
  B01111111, // 8
  B01101111  // 9
};

// Funkcja do wyświetlania cyfry na wybranym segmencie
void displayDigit(int digit, int position) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(segmentPins[i], (digitToSegment[digit] >> i) & 0x01);
  } // MASKI I TAKIE CUDA NAKLADANIE ODP PO INDEKSIE
  digitalWrite(dpPin, LOW); // Wyłączenie kropki dziesiętnej
  digitalWrite(ccPins[position], LOW); // WYBOR SEGMENTU
  delay(250); // Zwiększenie opóźnienia, aby zapewnić widoczność
  digitalWrite(ccPins[position], HIGH);
}

// Funkcja do wyświetlania liczby na 4-cyfrowym wyświetlaczu
void displayNumber(int number) {
  int num = number;
  for (int i = 0; i < 4; i++) {
    int digit = num % 10;
    displayDigit(digit, 3 - i); // Wyświetlanie od prawej do lewej
    num /= 10;
  }
}

// Funkcja do odczytywania wejścia z klawiatury (switchy)
char readKeypad() {
  for (int i = 0; i < 4; i++) {
    if (digitalRead(switchPins[i]) == LOW) {
      delay(50); // Debounce
      if (digitalRead(switchPins[i]) == LOW) {
        while (digitalRead(switchPins[i]) == LOW); // Czekaj na zwolnienie switcha
        switch (i) {
          case 0: return '1'; // Switch 1: cyfra 1
          case 1: return '2'; // Switch 2: cyfra 2
          case 2: return '3'; // Switch 3: cyfra 3
          case 3: return '+'; // Switch 4: operator +
        }
      }
    }
  }
  return '\0'; // Brak wciśniętego klawisza
}

void setup() {
  // Inicjalizacja pinów segmentów jako wyjścia
  for (int i = 0; i < 7; i++) {
    pinMode(segmentPins[i], OUTPUT);
  }
  pinMode(dpPin, OUTPUT);

  // Inicjalizacja pinów wspólnych katod jako wyjścia
  for (int i = 0; i < 4; i++) {
    pinMode(ccPins[i], OUTPUT);
    digitalWrite(ccPins[i], HIGH); // Wyłączenie wszystkich katod na start
  }

  // Inicjalizacja pinów switchy jako wejścia
  for (int i = 0; i < 4; i++) {
    pinMode(switchPins[i], INPUT_PULLUP);
  }

  // Inicjalizacja komunikacji szeregowej do debugowania
  Serial.begin(9600);
}

void loop() {
  char key = readKeypad();
  if (key != '\0') {
    if (isdigit(key)) {
      strncat(input, &key, 1);
      int num = atoi(input);
      displayNumber(num);
    } else if (key == '+') {
      if (strlen(input) > 0) {
        num1 = atoi(input);
        input[0] = '\0';
        operation = '+';
      }
    } else if (key == '=') {
      if (strlen(input) > 0) {
        num2 = atoi(input);
        if (operation == '+') {
          result = num1 + num2;
        }
        displayNumber(result);
        num1 = result;
        input[0] = '\0';
        operation = '\0';
      }
    }
  }
  
  // Aktualizowanie wyświetlania cyfr w pętli
  for (int i = 0; i < 4; i++) {
    displayNumber(result);
  }
}
*/