#include "DebounceFsm.h"
#include "gtest/gtest.h"
#include "gmock/gmock.h"

using ::testing::Test;
using ::testing::Return;

class MockClock : public Clock {
    public:
        MOCK_METHOD(uint32_t, getMillis, ());
};

class MockGpioInput : public GpioInput {
    public:
        MOCK_METHOD(bool, read, ());
};


class DebounceFsmTest : public Test {
    protected:

        DebounceFsmTest() :
            clock(),
            gpioInput(),
            activated(false),
            deactivated(false)
        {}
        ~DebounceFsmTest() {}

        static const unsigned int DEBOUNCE_MILLIS = 100;
        static const bool ACTIVE_VALUE = true;
        MockClock clock;
        MockGpioInput gpioInput;

        bool activated;
        bool deactivated;

        void SetUp() override {
            fsm = new DebounceFsm(
                clock,
                gpioInput,
                DEBOUNCE_MILLIS,
                ACTIVE_VALUE,
                [this](){activated = true;},
                [this](){deactivated = true;});
            ON_CALL(clock, getMillis()).WillByDefault(Return(0));
            ON_CALL(gpioInput, read()).WillByDefault(Return(!ACTIVE_VALUE));
            activated = false;
            deactivated = false;
        }

        void TearDown() override {
            fsm = nullptr;
        }

        DebounceFsm *fsm;
};

TEST_F(DebounceFsmTest, Noop) {

    EXPECT_CALL(clock, getMillis()).WillOnce(Return(0));
    EXPECT_CALL(gpioInput, read()).WillOnce(Return(ACTIVE_VALUE));
    fsm->step();
    EXPECT_EQ(false, activated);
    EXPECT_EQ(false, deactivated);

    EXPECT_CALL(clock, getMillis()).WillOnce(Return(DEBOUNCE_MILLIS));
    EXPECT_CALL(gpioInput, read()).WillOnce(Return(ACTIVE_VALUE));
    fsm->step();
    EXPECT_EQ(true, activated);
    EXPECT_EQ(false, deactivated);


}

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}