/**
 * @file motorControl.h
 * @author Alexander Klein (alex@kleiax.de)
 * @brief Inherits a class to control a motor with pwm signal.
 * @version 0.1
 * @date 2021-12-09
 * 
 * @copyright Copyright (c) 2021
 * 
 */
#ifndef MOTOR_CONTROL_H
#define MOTOR_CONTROL_H

#include <cstdint>
#include <string>
#include <iostream>
#include <Arduino.h>

#define DELAY 10
#define PWMFREQ 16000
#define PWMRES 8
#define POWERSTEPS 2       //  A total of 20 levels ( 100 / SPEED_STEPS ) * RUN_MOTOR_CONTROL_DELAY = 500ms
#define PWMMIN 55
#define PWMMAX 94         // Max 98% of 2^PWM_RES

/**
 * @brief A class which use PWM to control the power of DC Motor
 * You can control the acceleration of the motor, for example to
 * prevent a damage on your H-Bridge.
 */
class MotorControl {
    public:
        MotorControl();

        /**
         * @brief Initialize the motorController
         * 
         * @param pwmPin The output pin for the signal on the esp.
         * @param pwmChannel One of the pwm channels from the esp.
         * @param dir_1 First direction pin for the H-Bridge.
         * @param dir_2 Second direction pin for the H-Bridge.
         */
        void init(uint8_t pwmPin, uint8_t pwmChannel, uint8_t dir_1, uint8_t dir_2);

        /**
         * @brief Calls runMotorControl() to update the pwm signal
         * 
         * This function should be called every mainloop. If the delayLoop is not reached, than the
         * functions returns immediately.
         * @see runMotorControl()
         * @see DELAY
         * @return time since the last call in Milliseconds
         */
        uint16_t loop();

        /**
         * @brief Normally called repeatedly by loop() to update the pwm signal.
         * 
         * Checks the difference between target power and current power to
         * increase or decrease the duty cycle. The amount of decrease or increase
         * is set by setPowerSetps() (default = 2).
         */
        void runMotorControl();

        /**
         * @brief Set the minimum duty cycle
         * 
         * @param min duty cycle in percent
         */
        void setMinPwm(uint8_t min);

        /**
         * @brief Set the maximum duty cycle
         * 
         * @param max duty cycle in percent
         */
        void setMaxPwm(uint8_t max);

        /**
         * @brief Set the Power Steps
         * 
         * Set the increment of the steps with which the dutycycle is
         * increased or decreased. Note the dependency between the increment
         * and delayLoop().
         * 
         * The formula for the time between 0% and 100% power is:
         *      time[ms] = delayLoop * ( 100 / increment )
         *      500 ms are recommended
         * 
         * @see setDelay()
         * 
         * @param increment 
         * @return time from 0% power to 100% power in Milliseconds
         */
        uint16_t setPowerSteps(uint8_t increment);

        /**
         * @brief Set the Target Power
         * 
         * If the given power is greater than 100 or smaller than -100, then
         * this function only print an error to consol.
         * 
         * @param power power in percent 
         */
        void setTargetPower(int8_t power);

        /**
         * @brief Set the min delayLoop between each loop
         * 
         * Note the dependency between delayLoop and
         * setPowerSteps().
         * 
         * @see setPowerSteps()
         * 
         * @param delayLoop time in Milliseconds
         * @return time from 0% power to 100% power in Milliseconds
         */
        uint16_t setDelay(uint8_t delayLoop);

        /**
         * @brief Stops the motor like setTargetPower() to 0
         * 
         */
        void stop();

        /**
         * @brief Stops the motor immediately
         * 
         */
        void emergencyStop();

        /**
         * @brief Get the current power
         * 
         * @return int8_t percent of power (-100 to 100)
         */
        int8_t getPower();

        /**
         * @brief Get the target power
         * 
         * @return int8_t percent of power (-100 to 100)
         */
        int8_t getTargetPower();

        uint16_t getDutycycle() const { return this->dutycycle; }
        bool isTargetPowerReached();
        bool isAccelerationPositive();
        bool isAccelerationNegative();

    private:
        void setRealPower(int8_t power);
        void increasePower(int8_t power);

        int8_t targetPower = 0;
        int8_t power = 0;
        uint8_t direction = 0; // 0 = stop, 1 = forward, 2 = backward

        uint8_t pwmPin;
        uint8_t pwmChannel;
        uint8_t pwmRes = PWMRES;
        uint16_t dutycycle = 0;
        uint8_t dutycycleMin;
        uint8_t dutycycleMax;
        uint8_t dir_1;
        uint8_t dir_2;
        uint8_t delayLoop = DELAY;
        uint8_t powersteps = POWERSTEPS;

        uint32_t lastMillis = 0;
        
};

#endif // MOTOR_CONTROL_H