//------------------------Variable declaration & initialization----------------------------//

// For onboard LED //

    #define ledPin 2

// For user input //

    bool canRun1, canCalibrate, canCalibrate2;

// For buzzer //

    const int buzzPin = 13, buzzChan = 0;

    int dir = 1, maxFreq = 600, minFreq = 250, buzzFreq = minFreq;
    bool canSound, canStDy, canCount;
    unsigned long prevT, dyT_buzz = 10;
	
//---------------------------------Callback functions-------------------------------------//

//---------------------------------------Setup-------------------------------------------//

void setup() {
    Serial.begin(115200);
    Serial.printf("______________________Setup starts_________________________\n");
    pinMode(ledPin , OUTPUT);
    BuzzerSetup();
    Serial.printf("______________________Setup completes_________________________\n");
}

void BuzzerSetup(){
    ledcSetup(buzzChan, 5E3, 8); ledcAttachPin(buzzPin, buzzChan);
    // 2.5~5kHz for tone .
}
//----------------------------------------Loop--------------------------------------------//

void loop() {
    UserInput();
    BuzzBreath();
    if (canRun1 == true){
    }
}

void UserInput(){
    if (Serial.available()) {
        String input_str = Serial.readString();
        input_str.trim(); // remove "/n"
        Serial.printf("You entered: %s\n" , input_str);
        int input_int = input_str.toInt();
        if (input_str != "0" && input_int == 0){
                // input_str.toInt() will return 0 if input_str is not an integer .
            return;
        }
        
        if (canCalibrate){
            Calibrate(input_int);
            canCalibrate = false;
            return;
        }
        else if (canCalibrate2){
            Calibrate2(input_int);
            canCalibrate2 = false;
            return;
        }

        switch (input_int){
            case 0:
                Serial.printf("Stop running\n");
                canRun1 = false;
                break;
            case 1:
                Serial.printf("Start running\n");
                canRun1 = true;
                break;
            case 2:
                Serial.printf("Enter your value for calibration:\n");
                canCalibrate = true;
                break;
            case 3:
                Serial.printf("Enter your value for calibration:\n");
                canCalibrate2 = true;
                break;
            default:
                break;
        }
    }
}

    void Calibrate(int num1){
        BuzzInterface("single", num1);
    }

    void Calibrate2(int num1){
        BuzzInterface("breath", 0);
    }

//--------------------------------Self-defined functions------------------------------------//

void BuzzInterface(String actStr, int freq){
    if (actStr == "single"){
        canSound = false;
        ledcWriteTone(buzzChan, freq);
    }
    else if (actStr == "breath"){
        canSound = true;
    }
    else{
        return;
    }
}

void BuzzBreath(){
    if (canSound == false){
        canStDy = true; // Reset
	    if (canCount){
	        canCount = false;
		      buzzFreq = 0; ledcWriteTone(buzzChan, buzzFreq);
	    }
        return;
    }

    if (canStDy){
        prevT = millis(); canStDy = false; canCount = true;

        Serial.printf("Buzz freq: %d\n", buzzFreq);
        dir = (buzzFreq > maxFreq) ? -1 : (buzzFreq < minFreq) ? 1 : dir;
        if (dir == 1){
            ledcWriteTone(buzzChan, buzzFreq++);
        }
        else if (dir == -1){
            ledcWriteTone(buzzChan, buzzFreq--);
        }
    }
    else if (millis()-prevT >= dyT_buzz && canCount){
        canStDy = true; canCount = false;
        // Body
    }
}