constexpr uint8_t  PIN_MASTER_SIGNAL = 2;
constexpr uint8_t  PIN_END_SIGNAL    = A0;
constexpr uint8_t  PIN_ACTIVE_LED    = 13;
constexpr uint32_t DEBOUNCE_MS       = 500;

enum class SlaveState : uint8_t {
    IDLE,
    ACTIVE,
    PHASE1,
    PHASE2,
    END
};

struct Slave {
    SlaveState state      = SlaveState::IDLE;
    uint32_t   phaseStart = 0;
} slave;

bool phase1(uint32_t now) {
    if (now - slave.phaseStart < 5000) { //5 sec placeholder
        // To Do: fase 1
        return false; // Non completato
    }
    return true; // Completato
}

bool phase2(uint32_t now) {
    if (now - slave.phaseStart < 5000) { //5 sec placeholder
        // To Do: fase 2
        return false; // Non completato
    }
    return true; // Completato
}


void setup() {
    pinMode(PIN_MASTER_SIGNAL, INPUT);
    pinMode(PIN_END_SIGNAL, OUTPUT);
    pinMode(PIN_ACTIVE_LED, OUTPUT);
    digitalWrite(PIN_ACTIVE_LED, LOW);
    digitalWrite(PIN_END_SIGNAL, LOW);
}

void loop() {
    uint32_t now = millis();
    
    static bool     prevIdle     = false;
    static uint32_t edgeTimeIdle = 0;
    static bool     prevStop     = true;  
    static uint32_t edgeTimeStop = 0;

    bool sig = digitalRead(PIN_MASTER_SIGNAL);

    // IDLE
    if (slave.state == SlaveState::IDLE) {
        if (sig != prevIdle) {
            prevIdle = sig;
            edgeTimeIdle = now;
        }

        if (sig && (now - edgeTimeIdle >= DEBOUNCE_MS)) {
            slave.state      = SlaveState::ACTIVE;
            slave.phaseStart = now;
            digitalWrite(PIN_ACTIVE_LED, HIGH);
        }
    }

    // STOP
    else if (slave.state != SlaveState::END) {
        if (sig != prevStop) {
            prevStop = sig;
            if (!sig) {  
                edgeTimeStop = now;
            }
        }

        if (!sig && (now - edgeTimeStop >= DEBOUNCE_MS)) {
            slave.state = SlaveState::END;
            digitalWrite(PIN_ACTIVE_LED, LOW);
        }
    }

    // MACCHINA A STATI
    switch (slave.state) {
        case SlaveState::IDLE:
            // To Do: in attesa della partenza
            break;

        case SlaveState::ACTIVE:
            // To Do: preparazione
            slave.state      = SlaveState::PHASE1;
            slave.phaseStart = now;
            break;

        case SlaveState::PHASE1:
            if (phase1(now)) {
                slave.state      = SlaveState::PHASE2;
                slave.phaseStart = now;
            }
            break;

        case SlaveState::PHASE2:
            if (phase2(now)) {
                digitalWrite(PIN_ACTIVE_LED, LOW);
                digitalWrite(PIN_END_SIGNAL, HIGH);            
                slave.state = SlaveState::END;
            }
            break;

        case SlaveState::END:
            bool master_is_high = digitalRead(PIN_MASTER_SIGNAL);
            digitalWrite(PIN_END_SIGNAL, master_is_high ? HIGH : LOW);            
            break;
    }
}