#include <print>
#include <thread>
#include <unistd.h>


class Motor
{
public:
    enum Direction { FORWARD, BACKWARD, NONE };
    void forward() { _direction = FORWARD; }
    void backward() { _direction = BACKWARD; }
    void stop() { _direction = NONE; }

private:
    Direction _direction;
};

class FSM
{
public:
    enum State { OPEN, CLOSED, OPENING, CLOSING };

public:
    FSM(Motor& motor) : _motor(motor), _state(OPEN) {}

    State state() const { return _state; }
    const char* state_str() const
    {
        switch (_state) {
            case OPEN: return "OPEN"; 
            case CLOSED: return "CLOSED";
            case OPENING: return "OPENING"; 
            case CLOSING: return "CLOSING";
        }
        return "OJE";
    }
    
    void dwim_pressed()
    {
        switch (_state) {
            case OPEN:
                _motor.backward();
                _state = CLOSING;
                break;
            case CLOSED:
                _motor.forward();
                _state = OPENING;
                break;
            case OPENING:
                _motor.backward();
                _state = CLOSING;
                break;
            case CLOSING:
                _motor.forward();
                _state = OPENING;
                break;
        }        
    }
    void open_position_reached()
    {
        switch (_state) {
            case OPEN:
                std::println("wtf?");
                break;
            case CLOSED:
                std::println("wtf?");
                break;
            case OPENING:
                _motor.stop();
                _state = OPEN;
                break;
            case CLOSING:
                std::println("wtf?");
                break;
        }        
    }
    void closed_position_reached()
    {
        switch (_state) {
            case OPEN:
                std::println("wtf?");
                break;
            case CLOSED:
                std::println("wtf?");
                break;
            case OPENING:
                std::println("wtf?");
                break;
            case CLOSING:
                _motor.stop();
                _state = CLOSED;
                break;
        }        
    }

private:
    Motor _motor;
    State _state;
};

class Button
{
public:
    bool is_pressed() { return true; }
};


Motor motor;
FSM fsm(motor);

Button dwim;
Button closed_position;
Button open_position;

void plc_loop()
{
    // PLC loop
    while (true) {
        if (dwim.is_pressed())
            fsm.dwim_pressed();
        if (closed_position.is_pressed())
            fsm.closed_position_reached();
        if (open_position.is_pressed())
            fsm.open_position_reached();

        std::println("state: {}", fsm.state_str());

        sleep(1);
    }
}

void cmdline_loop()
{
    while (true) {
        char buffer[1024] = {0};
        ssize_t nread = read(0, buffer, sizeof(buffer)-1);
        if (nread == -1) {
            perror("read");
            break;
        }

        std::println("debug line: {}", buffer);

        std::string line = buffer;
        if (line == "dwim\n")
            fsm.dwim_pressed();

        std::println("state: {}", fsm.state_str());
    }
}

int main()
{
    std::thread plc_thread(plc_loop);
    std::thread cmdline_thread(cmdline_loop);

    plc_thread.join();
    cmdline_thread.join();

    return 1;
}
