/*********by: Ko Yan Fai Anthony*********/
//Product: Coffee maker
//Test

//Brew Output Control Pin x4
const int Pump_1 = 23;
const int Pump_2 = 22;
const int Heater = 21;
const int PTC_Heater = 18;
const int Motor = 19;

// Input Pin
const int NTC_Pin = 39; //ADC
const int Water_Sensor_Pin = 36; //Digitial
const int Micro_Switch_Pin = 34;

//LED Pin x9
const int Ex_Hot_LED = 5;
const int To_Go_LED = 17;
const int L_Temp_LED = 16;
const int Iced_LED = 4;
const int Mode_LED = 0;
const int Slow_LED = 2;
const int Strong_LED = 15;
const int Cup2_LED = 12;
const int Cup4_LED = 14;

//Button Input Pin x5
const int Mode_Button = 32;
const int Slow_Button = 33;
const int Strong_Button = 25;
const int Cup2_Button = 26;
const int Cup4_Button = 27;

// Variables
// NTC Temperatue 
int NTC_Temperature = 0; //ADC
// Heater temperature limite 
const int Clean_temp = 92, Normal_Brewing_temp = 91, Coffee_to_go_temp = 95, Low_t_brew_temp = 89, Ice_coff_temp = 89;

// PTC heater
//const int PTC_Clean_temp ;

// Mode 
int Mode_count = 0;
const int Ex_Hot_Mode = 4, To_Go_Mode = 3 , L_Temp_Mode = 2, Iced = 1;

bool Slow_stage = 0 , Strong_Stage = 0, Cup2_Stage = 0, Cup4_Stage = 0;

//button debounce
bool buttonState = HIGH;             // the current reading from the input pin
bool reading;                 
bool lastButtonState[5]={HIGH, HIGH, HIGH, HIGH, HIGH};
const int  _mode_= 0, slow= 1, strong= 2, cup2 = 3, cup4 = 4; // for lastButtonState array
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers

//Clean_mode button hold key
bool hold_key_state = LOW, Clean_mode = 0;
const int hold_time = 5000, Idle = 200;
long hold_time_count = 0, idle_previousMillis = 0;

//LED blink
unsigned long currentMillis = 0, previousMillis = 0;
const int interval_1s = 1000, interval_250ms = 250, interval_200ms = 200, interval_500ms = 500, interval_5s = 5000;  
bool ledState = LOW;

//brew process

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

  //Brew Control Pin setup
  pinMode( Pump_1, OUTPUT);
  pinMode( Pump_2, OUTPUT);
  pinMode( Heater, OUTPUT);
  pinMode( PTC_Heater, OUTPUT);
  pinMode( Motor, OUTPUT);

  //Button Input Pin setup ACTIVE LOW
  pinMode( Mode_Button,INPUT_PULLUP);
  pinMode( Slow_Button,INPUT_PULLUP);
  pinMode( Strong_Button,INPUT_PULLUP);
  pinMode( Cup2_Button,INPUT_PULLUP);
  pinMode( Cup4_Button,INPUT_PULLUP);

  //LED Pin
  pinMode( Ex_Hot_LED, OUTPUT);
  pinMode( To_Go_LED, OUTPUT);
  pinMode( L_Temp_LED, OUTPUT);
  pinMode( Iced_LED, OUTPUT);
  pinMode( Mode_LED, OUTPUT);
  pinMode( Slow_LED, OUTPUT);
  pinMode( Strong_LED, OUTPUT);
  pinMode( Cup2_LED, OUTPUT);
  pinMode( Cup4_LED, OUTPUT);

  //Input Pin
  pinMode( Water_Sensor_Pin, INPUT);
  pinMode( Micro_Switch_Pin, INPUT);

  //Start LED hardware init 
  Standby_mode();
  Serial.println("START");
}

void loop() 
{
  if(button( Mode_Button, _mode_))  //Mode
  {
    Set_mode();
    Serial.print("MODE" );
    Serial.println(Mode_count);
  }

  if(button(Slow_Button, slow))   //Slow
  {
    Set_slow_strong_cup(Slow_LED, Slow_stage);
    Serial.print("SLOW");
    Serial.println(Slow_stage);
  } 

  if(button(Strong_Button, strong)) //Strong
  {
    Set_slow_strong_cup(Strong_LED, Strong_Stage);
    Serial.print("STRONG");
    Serial.println(Strong_Stage);
  }

  if(button(Cup2_Button ,cup2) && Mode_count) //2 Cup
  {
    Serial.println("Cup2");
    digitalWrite(Cup4_LED, LOW);
    Set_slow_strong_cup(Cup2_LED, Cup2_Stage);
    while(1)
    {
      //case 1
      if(Water_open_detect())
        break;

      //case 2
      LED_Blink(Cup2_LED, interval_1s, interval_1s);

      //
      if(button(Cup2_Button ,cup2))
      {
        End_Action();
        break;
      }
    }
    Serial.println("End Cup2");
    End_Action();
  }

  if(button(Cup4_Button ,cup4) && (Mode_count && Mode_count !=To_Go_Mode && Mode_count != Iced )) //4 Cup
  {
    Serial.println("Cup4");
    digitalWrite(Cup2_LED, LOW);
    Set_slow_strong_cup(Cup4_LED, Cup4_Stage);
    while(1)
    {
      //case 1
      if(Water_open_detect())
       break;
      
      //case 2
      LED_Blink(Cup4_LED, interval_1s, interval_1s);

      //
      if(button(Cup4_Button ,cup4))
      {
        End_Action();
        break;
      }
    }
    Serial.println("End Cup4");
    End_Action();
  }

  if(Clean_mode)
  {
    Serial.println("CLEANING");
    //case 1
    Clean_mode = !(Water_open_detect());
    
    // water heating
      Clean_water_heating();
    
    while(Clean_mode)
    {
      LED_Blink(Cup4_LED, interval_500ms, interval_500ms);
      if(button(Cup4_Button ,cup4))
      {
        Serial.println("End CLEANING");
        End_Action();
        Clean_mode = 0;
      }
    }
  }

}

void Clean_water_heating()
{
  digitalWrite(Heater, HIGH);
  while(analogRead(Heater) <= Clean_temp)
    LED_Blink(Cup4_LED, interval_500ms, interval_500ms);
  
  digitalWrite(Heater, LOW);
  idle_previousMillis = millis() ;

  while( millis() - idle_previousMillis >= interval_200ms)
    LED_Blink(Cup4_LED, interval_500ms, interval_500ms);
}

bool Water_open_detect()
{
  if(digitalRead(Water_Sensor_Pin) == LOW)
  {   
    Serial.println("Open");
    digitalWrite(Cup4_LED, HIGH);
    delay(200);
    digitalWrite(Cup4_LED, LOW);
    delay(5000);
    return true;
  }
  else 
    return false;
}

void LED_Blink(int LED_Pin, int On_interval, int Off_interval)
{
  currentMillis = millis();
  if (currentMillis - previousMillis >= Off_interval && !ledState) 
  {
    previousMillis = currentMillis;
    Serial.println("Blink");
    ledState = HIGH;
    digitalWrite(LED_Pin, ledState);
  }
  if(currentMillis - previousMillis >= On_interval && ledState)
  {
    previousMillis = currentMillis;
    Serial.println("Off");
    ledState = LOW;
    digitalWrite(LED_Pin, ledState);
  }
}

void End_Action()
{
  ledState = 0;
  Mode_count = 0;
  Slow_stage = 0;
  Strong_Stage = 0;
  Cup2_Stage = 0;
  Cup4_Stage = 0;
  Standby_mode();
}

void Set_slow_strong_cup(int LED_Pin, bool &Stage)
{
  if(Stage>=1)
    Stage = 0;
  else
    Stage ++;
  digitalWrite(LED_Pin, Stage);
}

void Set_mode()
{
  Mode_count++;
  if(Mode_count >= 5)
    Mode_count = 0;
  switch(Mode_count)
  {
    case 0:
      digitalWrite(Ex_Hot_LED, LOW);
      digitalWrite(To_Go_LED, LOW);
      digitalWrite(L_Temp_LED, LOW);
      digitalWrite(Iced_LED, LOW);
      break;

    case Iced:
      digitalWrite(Ex_Hot_LED, LOW);
      digitalWrite(To_Go_LED, LOW);
      digitalWrite(L_Temp_LED, LOW);
      digitalWrite(Iced_LED, HIGH);
      break;

    case L_Temp_Mode:
      digitalWrite(Ex_Hot_LED, LOW);
      digitalWrite(To_Go_LED, LOW);
      digitalWrite(L_Temp_LED, HIGH);
      digitalWrite(Iced_LED, LOW);
      break;

    case To_Go_Mode:
      digitalWrite(Ex_Hot_LED, LOW);
      digitalWrite(To_Go_LED, HIGH);
      digitalWrite(L_Temp_LED, LOW);
      digitalWrite(Iced_LED, LOW);
      break;
    case Ex_Hot_Mode:
      digitalWrite(Ex_Hot_LED, HIGH);
      digitalWrite(To_Go_LED, LOW);
      digitalWrite(L_Temp_LED, LOW);
      digitalWrite(Iced_LED, LOW);
    default:
      Serial.println("ERROR MODE");
  }

  if(Mode_count == To_Go_Mode || Mode_count == Iced)
    digitalWrite( Cup4_LED, LOW);
}

void Standby_mode()
{
  Mode_count = 0;
  digitalWrite(Ex_Hot_LED, LOW);
  digitalWrite(To_Go_LED, LOW);
  digitalWrite(L_Temp_LED, LOW);
  digitalWrite(Iced_LED, LOW);
  digitalWrite(Mode_LED, LOW);
  digitalWrite(Slow_LED, LOW);
  digitalWrite(Strong_LED, LOW);
  
  digitalWrite(Mode_LED, HIGH);
  digitalWrite(Cup2_LED, HIGH);
  digitalWrite(Cup4_LED, HIGH);
}



///////////////////Button read
bool button(int buttonPin, int type)//Release To Triggler
{
  reading = digitalRead(buttonPin);
  if ((millis() - lastDebounceTime) > debounceDelay && reading != lastButtonState[type]) 
  {
    hold_key_state = false;
    hold_time_count = millis();
    lastDebounceTime = millis();
    if (reading != buttonState) 
    {
      buttonState = reading;
      if (buttonState == LOW)
      {
        if(buttonPin==Cup4_Button)
          hold_key_state = true;
        lastButtonState[type] = reading;
        return true;
      }
    }
  }

  if(hold_key_state && reading == lastButtonState[type] && (millis()-lastDebounceTime>hold_time) )
  {
    Serial.println("Clean");
    hold_key_state = false;
    Clean_mode = true;
  }

  lastButtonState[type] = reading;
  return false;
}