//displays from 0 through 9; 
byte seg[] = {
  B00000011, 
  B10011111, 
  B00100101, 
  B00001101, 
  B10011001, 
  B01001001, 
  B01000001, 
  B00011111, 
  B00000001, 
  B00001001};

const int segmentPins[]={37,36,35,34,33,32,31,30};
const int numberOfDigits = 4;
int digitPins[numberOfDigits] = {13,12,11,10};

int totalMinutes = 1440;
int minutes = 0;
int hours = 0;

int i = 0;
static unsigned long countStart = 1;
int currentValue = 1;

unsigned long interval = 1000;
const int soundInterval = 3000;
unsigned long time = 0;
unsigned long soundTime = 0;
unsigned long silenceTime = 0;

const int buzzer = 9;
volatile byte ledState = LOW;

static bool flag = false;
int alarmNumber = -1;

//clock mode: HIGH (OFF) to set the alarm time; LOW (ON) to set the clock time
volatile bool mode = false;
#define modePin 22
static bool modeState = true;

unsigned long lastMillis = 0;

//blue button debounce implementation
#define switched true
#define triggered true
#define interrupt_trigger_type RISING
#define debounce 50

volatile bool interrupt_process_status = {!triggered};
static bool switch_pending = false;
bool initialization_complete = false;
static long int elapsed_timer;

volatile static bool blueFlag = false;
unsigned long blueElapsed = 0;
unsigned long blueDebounce = 50;

int button_switch = 19;


//Extra  features
static bool alarmEnableFlag = false;  //Enable button (yellow)
unsigned long enableElapsed = 0;
unsigned long enableDebounce = 55;
#define enableLED 7
volatile byte enableLEDState = LOW;


//alarm hour button (white)
#define hourPin 20
#define setTimeLED 16
volatile byte setTimeLEDState = LOW;
unsigned long elapsedTimeButton = 0;
unsigned long timeButtonDebounce = 50;
static bool setTimeFlag = false;
static int userSetHour = 0;


//alarm minutes button (black)
#define minutePin 2
unsigned long elapsedMinuteButton = 0;
static int userSetMinute = 0;
static bool setMinuteFlag = false;


//clock hour button (white)
static bool setTimeFlagClock = false;
static int userSetTimeHour = 0;

//clock minutes button (black)
static int userSetTimeMinute = 0;
static bool setMinuteFlagClock = false;



//Set Button and LED  (Green)
#define SET_LED 8
#define SET_Button 18
volatile byte SET_LED_State = LOW;
static bool setFlag = false;
unsigned long setElapsed = 0;


void setup() {
  //mode
  pinMode(modePin,INPUT_PULLUP);
  
  //Set LED
  pinMode(SET_LED,OUTPUT);
  pinMode(SET_Button, INPUT_PULLUP);

  //minute button
  pinMode(minutePin,INPUT_PULLUP);
  //hour button
  pinMode(hourPin, INPUT_PULLUP);
  pinMode(setTimeLED, OUTPUT);
  //enable/disable alarm feature button - yello
  pinMode(21, INPUT_PULLUP);
  //button
 // pinMode(button_Pin, INPUT_PULLUP);
  pinMode(19, INPUT_PULLUP);
  pinMode(7, OUTPUT);
  pinMode(3, INPUT_PULLUP);

  //button interrupt
  attachInterrupt(digitalPinToInterrupt(SET_Button),userSet,RISING);
  //attachInterrupt(digitalPinToInterrupt(19),button_interrupt_handler,interrupt_trigger_type);
  attachInterrupt(digitalPinToInterrupt(19),blueButton,RISING);
  attachInterrupt(digitalPinToInterrupt(21),alarmEnable,RISING);
  attachInterrupt(digitalPinToInterrupt(hourPin),setHour,RISING);
  attachInterrupt(digitalPinToInterrupt(minutePin),setMinute,RISING);
  attachInterrupt(digitalPinToInterrupt(3),changeMode,CHANGE);

  //configures PORTC as outputs.
  DDRC = B11111111;

  //attach the piezo buzzer
  pinMode(buzzer, OUTPUT);

  //configures the digitPins as outputs
  for(int i=0;i<numberOfDigits;i++){
    pinMode(digitPins[i],OUTPUT);
  }
  Serial.begin(9600);
  initialization_complete = true;
}

  void changeMode(){
    modeState = !modeState;
    resetCountStart();
  }

  void resetCountStart(){
    if(modeState==HIGH){
      //Serial.println("nothing");
      return;
    }else{
      countStart = 0;
      //userSetHour = 0;
      //userSetMinute =0;
      userSetTimeMinute = 0;
      userSetTimeMinute = 0;

      //Serial.println("clearto 0");
    }
  }

  void userSet(){
    setFlag = true;
  }

  void set(){
    if(millis()-setElapsed > debounce){
      setElapsed = millis();
      if(digitalRead(SET_Button)==HIGH && setFlag){
        SET_LED_State = !SET_LED_State;
        digitalWrite(SET_LED,SET_LED_State);
        setFlag = false;
      }
    }
  }


  void setMinute(){
    setMinuteFlag = true;
  }

  void minuteToggle(){
    if(millis()-elapsedMinuteButton > timeButtonDebounce){
      elapsedMinuteButton = millis();
      if(digitalRead(minutePin)==HIGH && setMinuteFlag && modeState==1){
        userSetMinute = (userSetMinute+1)%60;
        alarmNumber = alarmNumber + 1; 
        setMinuteFlag = false;
      }
    }
  }

    void clockMinuteToggle(){
    if(millis()-elapsedMinuteButton > timeButtonDebounce){
      elapsedMinuteButton = millis();
      if(digitalRead(minutePin)==HIGH && setMinuteFlag && modeState==0){
        userSetTimeMinute = (userSetTimeMinute+1)%60;
        //userSetMinute = (userSetMinute+1)%60;
        countStart = countStart + 1; 
        setMinuteFlag = false;
      }
    }
  }

  void setHour(){
    setTimeFlag = true;
  }

  void hourToggle(){
    if(millis()-elapsedTimeButton > timeButtonDebounce){
      elapsedTimeButton = millis();
      if(digitalRead(hourPin)==HIGH && setTimeFlag && modeState==1){
        setTimeLEDState = !setTimeLEDState;
        digitalWrite(setTimeLED,setTimeLEDState);
        userSetHour = (userSetHour+1)%24;
        alarmNumber = userSetHour*60; 
        setTimeFlag = false;
      }
    }
  }

   void clockHourToggle(){
    if(millis()-elapsedTimeButton > timeButtonDebounce){
      elapsedTimeButton = millis();
      if(digitalRead(hourPin)==HIGH && setTimeFlag && modeState==0){
        setTimeLEDState = !setTimeLEDState;
        digitalWrite(setTimeLED,setTimeLEDState);
        userSetTimeHour = (userSetTimeHour+1)%24;
        //userSetHour = (userSetHour+1)%24;
        countStart = 60+countStart; 
        setTimeFlag = false;
      }
    }
  }


  void alarmEnable(){
    alarmEnableFlag = true;
  }

  void readEnableButton(){
    if(millis()- enableElapsed > enableDebounce){
      enableElapsed = millis();
      if(digitalRead(21)==HIGH && alarmEnableFlag){
        Serial.println("yes");
        enableLEDState = !enableLEDState;
        digitalWrite(enableLED,enableLEDState);
        alarmEnableFlag = false;
      }
    }
  }

  void blueButton(){
    blueFlag = true;
    flag=false;
  }

  void readBlueButton(){
    if(millis()-blueElapsed>blueDebounce){
      blueElapsed = millis();
      if(digitalRead(19) == HIGH  && flag == false && blueFlag){
        noTone(buzzer);
        Serial.println("blue");
        blueFlag = false;
      }
    }
  }


//The reset routine
void reset(){
  for(int i=0;i<numberOfDigits;i++){
    digitalWrite(digitPins[i],LOW);
  }
  for(int j=0;j<8;j++){
    digitalWrite(segmentPins[j], HIGH);
  }
}

//displays a digit on a selected pin
void displayDigit(int digit, int pin){
  reset();
  digitalWrite(digitPins[pin], HIGH);
  PORTC=seg[digit];
  digitalWrite(digitPins[pin], LOW);
}

//displays minutes on the RHS two digits
void displayMinutes(int minutes){
  for(int i=0;i<2;i++){
    displayDigit(minutes%10,i);
    minutes = minutes/10;
  }
}

//displays hours on the third and fourth digits
void displayHour(int hours){
  for(int i=2;i<4;i++){
    displayDigit(hours%10,i);
    hours = hours/10;
  }
}

void tick(){
  countStart = countStart%1440;
  minutes = countStart - (int(countStart/60))*60;
  hours = (int) countStart/60;
  countStart++;
}

void nonblockingDelay(){
    if(millis() >= time+interval){
    time+=interval;
    //Serial.println("hello");
    tick();
  }
}

void nonBlockingDelayV2(){

  while(i<60){
    if((millis()-lastMillis) > 1000){
      lastMillis = millis();
        i++;
        displayHour(hours);
      displayMinutes(minutes);
        Serial.println(i);
    }
  }
  tick();
  i=0;
}

void nonblockingAlarm(){
  if(millis()>= soundTime+soundInterval){
    soundTime+=1000;
    tone(buzzer,1000);
    Serial.println("sound");
  }
}

void nonblockingSilence(){
  if(millis()>= silenceTime+1500){
    silenceTime+=1000;
    noTone(buzzer);
    Serial.println("silence");
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  //modeState = digitalRead(modePin);
  //delay(1000);
  //Serial.print("mode: ");
  //Serial.println(modeState); // 0-set time (HIGH,active low), 1-set alarm
  //Serial.print("count: ");
  Serial.println(countStart);

  if(modeState){
     if(SET_LED_State == HIGH){
      displayHour(userSetHour);
      displayMinutes(userSetMinute);
      //nonBlockingDelayV2();
      nonblockingDelay();
    }else{
      displayHour(hours);
      displayMinutes(minutes);
      nonblockingDelay();
      //nonBlockingDelayV2();
    }
  }else{
     displayHour(userSetTimeHour);
     displayMinutes(userSetTimeMinute);
    /*
    if(SET_LED_State == HIGH){
      displayHour(userSetTimeHour);
      displayMinutes(userSetTimeMinute);
      nonblockingDelay();
      //nonBlockingDelayV2();
    }else{
      displayHour(hours);
      displayMinutes(minutes);
      nonblockingDelay();
      //nonBlockingDelayV2();
    }
    */
  }
 

  if(countStart == alarmNumber && flag == false && enableLEDState ==1){
    flag = true;
  }
  
  if(flag && enableLEDState==1){
      nonblockingAlarm();
      nonblockingSilence();
  }

  readBlueButton();
  readEnableButton();

  if(modeState){
     hourToggle();
     minuteToggle();
     set();
  }else{
    clockHourToggle();
    clockMinuteToggle();
  }
 
  
  //Serial.println(alarmNumber);
}