// Abstract state machine. Ticks are deterministic model steps, not hardware time.
#include <iostream>

enum class State { active, sleeping, waking, fault };

struct Device {
    State state = State::active;
    int config = 42;

    bool sleep(bool idle)
    {
        if (state != State::active || !idle) {
            return false;
        }
        state = State::sleeping;
        return true;
    }

    bool wake(int acknowledgement_tick, int budget, bool lose_config = false)
    {
        if (state != State::sleeping) {
            return false;
        }
        state = State::waking;
        for (int tick = 0; tick < budget; ++tick) {
            if (tick == acknowledgement_tick) {
                if (lose_config) {
                    config = 0;
                }
                state = State::active;
                return true;
            }
        }
        state = State::fault;
        return false;
    }
};

int main()
{
    int failures = 0;
    auto check = [&](bool ok, const char* name) {
        std::cout << (ok ? "PASS " : "FAIL ") << name << '\n';
        failures += !ok;
    };
    Device d;
    check(!d.sleep(false) && d.state == State::active, "busy device refuses sleep");
    check(d.sleep(true), "idle device enters sleep");
    check(d.wake(2, 3) && d.config == 42, "wake at final allowed tick retains config");
    Device late;
    late.sleep(true);
    check(!late.wake(3, 3) && late.state == State::fault, "late acknowledgement times out");
    Device missing;
    missing.sleep(true);
    check(!missing.wake(-1, 3), "missing acknowledgement has bounded wait");
    Device corrupt;
    corrupt.sleep(true);
    bool woke = corrupt.wake(1, 3, true);
    check(woke && corrupt.config != 42, "injected retention fault detected");
    check(!d.wake(0, 3), "wake rejected while already active");
    return failures ? 1 : 0;
}