#include <iostream>
#include <chrono>
#include <ctime>
#include <cmath>

bool SYSTEMRUNNING = false;
class UTimer
{
private:
    std::chrono::time_point<std::chrono::system_clock> m_StartTime;
    std::chrono::time_point<std::chrono::system_clock> m_EndTime;
    bool m_bRunning = false;
public:
    void start()
    {
        m_StartTime = std::chrono::system_clock::now();
        m_bRunning = true;
    }
    void stop()
    {
        m_EndTime = std::chrono::system_clock::now();
        m_bRunning = false;
    }
    double elapsedMilliseconds()
    {
        std::chrono::time_point<std::chrono::system_clock> endTime;
        if(m_bRunning)
        {
            endTime = std::chrono::system_clock::now();
        }
        else
        {
            endTime = m_EndTime;
        }
        return std::chrono::duration_cast<std::chrono::milliseconds>(endTime - m_StartTime).count();
    }
    double elapsedSeconds()
    {
        return elapsedMilliseconds() / 1000.0;
    }
};
class Robog
{
private:
    bool POWER;
    float y;
    float accentuate;
    float xlin;
public:
    bool waitforinstruction = true;
    class RobogUpdateModule
    {
    public:
        UTimer updateTimer;
        void update(float delta_time)
        {
            updateTimer.start();
            int counter = 0;
            while(updateTimer.elapsedSeconds() < 10.0)
            {
                counter++;
                std::cout << counter << std::endl;
            }
            //-NOTE Update Method IF
        }
    };
    RobogUpdateModule ROBOGUPDATEMODULE;
    // ROBOG POWEROPERATIONS
    bool ROBOG_OPERATING_STATUS(bool power){
        POWER = power;
    }
    bool getROBOG_OPERATING_STATUS(){
        if (POWER){
            return "SYSTEM ON";
        }
        else
        {
            return "SYSTEM OFF";
        }
    }
    bool ROBOG_PAUSE(bool status)
    {
        std::cin.get();
    }
    // ROBOG BRAINCOMPUTING
     void activatePropagation(){
         y += 1;
     }
     void propagateForward(float &_W, const float _BIAS)
     {
         y = _W + _BIAS * _BIAS;
         _W = accentuate;
         xlin = _BIAS;
     }
     void Error(const float &x){
         accentuate * xlin * xlin -x;
     }
};
class ProcessTimer : Robog
{
private:
    std::chrono::time_point<std::chrono::system_clock> m_StartTime;
    std::chrono::time_point<std::chrono::system_clock> m_EndTime;
    bool m_bRunning = false;
public:
    void start()
    {
        m_StartTime = std::chrono::system_clock::now();
        m_bRunning = true;
    }
    void stop()
    {
        m_EndTime = std::chrono::system_clock::now();
        m_bRunning = false;
    }
    double elapsedMilliseconds()
    {
        std::chrono::time_point<std::chrono::system_clock> endTime;
        if(m_bRunning)
        {
            endTime = std::chrono::system_clock::now();
        }
        else
        {
            endTime = m_EndTime;
        }
        return std::chrono::duration_cast<std::chrono::milliseconds>(endTime - m_StartTime).count();
    }
    double elapsedSeconds()
    {
        return elapsedMilliseconds() / 1000.0;
    }
};

int main(int argc, char **argv)
{
    SYSTEMRUNNING = true;
    Robog ROBOG;
    ProcessTimer timer;
    ROBOG.waitforinstruction = true;
    while (ROBOG.ROBOG_OPERATING_STATUS(true))
    {

        if (ROBOG.ROBOG_OPERATING_STATUS(true))
        {
            ROBOG.ROBOGUPDATEMODULE.update(1.0);
        }
        else if (ROBOG.ROBOG_PAUSE(true))
        {
            if (ROBOG.ROBOG_PAUSE(false))
            {
                std::cout << "System RESUME" << std::endl;
            }
        }
        /*
        timer.start();
        int counter = 0;
        while(timer.elapsedSeconds() < 1.0)
        {
            counter++;
        }
        //timer.stop();
        //return 0;
         */
    }
}