#include "plc_device.h"
#include "plsr_persistence.h"
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>

static unsigned int TestCount;

#define TEST_CHECK(condition)                                                   \
    do                                                                          \
    {                                                                           \
        TestCount++;                                                            \
        if (!(condition))                                                       \
        {                                                                       \
            (void)fprintf(stderr, "FAIL line %d: %s\n", __LINE__, #condition); \
            exit(EXIT_FAILURE);                                                 \
        }                                                                       \
    } while (0)

static void TestAddressMap(void)
{
    uint16_t eventAddress;

    TEST_CHECK(PlsrAxisAddressMap[0].hsdRuntimeBase == 0U);
    TEST_CHECK(PlsrAxisAddressMap[3].hsdRuntimeBase == 12U);
    TEST_CHECK(PlsrAxisAddressMap[0].smPulseActiveAddress == 1000U);
    TEST_CHECK(PlsrAxisAddressMap[3].smDirectionAddress == 1061U);
    TEST_CHECK(PlsrAxisAddressMap[2].sdRuntimeBase == 1040U);
    TEST_CHECK(PlsrAxisAddressMap[3].eventBase == 6300U);

    TEST_CHECK(PlcDeviceGetEventAddress(0U, 1U, &eventAddress) == PLC_DEVICE_OK);
    TEST_CHECK(eventAddress == 6000U);
    TEST_CHECK(PlcDeviceGetEventAddress(3U, 100U, &eventAddress) == PLC_DEVICE_OK);
    TEST_CHECK(eventAddress == 6399U);
    TEST_CHECK(PlcDeviceGetEventAddress(4U, 1U, &eventAddress)
               == PLC_DEVICE_INVALID_ARGUMENT);
    TEST_CHECK(PlcDeviceGetEventAddress(0U, 0U, &eventAddress)
               == PLC_DEVICE_INVALID_ARGUMENT);
}

static void TestHsdAndPersistence(void)
{
    int32_t value32;
    int64_t value64;
    const int64_t firstPair = INT64_C(0x1234567887654321);
    const int64_t secondPair = -INT64_C(0x102030405060708);

    PlsrPersistenceTestResetStorage();
    TEST_CHECK(PlcDeviceInit() == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceGetLastHsdLoadResult() == PLSR_PERSISTENCE_DEFAULTED);
    TEST_CHECK(PlcDeviceIsHsdDirty() != 0U);

    TEST_CHECK(PlcDeviceWriteHsdConfig(460U, 11) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceWriteHsdConfig(539U, -22) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceWriteHsdConfig(0U, 1) == PLC_DEVICE_READ_ONLY);
    TEST_CHECK(PlcDeviceWriteHsdConfig(459U, 1) == PLC_DEVICE_INVALID_ADDRESS);
    TEST_CHECK(PlcDeviceReadHsd(460U, &value32) == PLC_DEVICE_OK);
    TEST_CHECK(value32 == 11);
    TEST_CHECK(PlcDeviceReadHsd(539U, &value32) == PLC_DEVICE_OK);
    TEST_CHECK(value32 == -22);
    TEST_CHECK(PlcDeviceReadHsd(540U, &value32) == PLC_DEVICE_INVALID_ADDRESS);

    TEST_CHECK(PlcDevicePublishHsdPair(0U, firstPair) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceReadHsdPair(0U, &value64) == PLC_DEVICE_OK);
    TEST_CHECK(value64 == firstPair);
    TEST_CHECK(PlcDeviceReadHsdPair(1U, &value64) == PLC_DEVICE_INVALID_ADDRESS);
    TEST_CHECK(PlcDeviceCheckpointHsd() == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceIsHsdDirty() == 0U);

    TEST_CHECK(PlcDeviceWriteHsdConfig(460U, 22) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDevicePublishHsdPair(0U, secondPair) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceCheckpointHsd() == PLC_DEVICE_OK);

    PlsrPersistenceTestCorruptNewestHsd();
    TEST_CHECK(PlcDeviceInit() == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceGetLastHsdLoadResult() == PLSR_PERSISTENCE_OK);
    TEST_CHECK(PlcDeviceReadHsd(460U, &value32) == PLC_DEVICE_OK);
    TEST_CHECK(value32 == 11);
    TEST_CHECK(PlcDeviceReadHsdPair(0U, &value64) == PLC_DEVICE_OK);
    TEST_CHECK(value64 == firstPair);
}

static void TestSfd(void)
{
    int32_t value;

    TEST_CHECK(PlcDeviceWriteSfd(900U, 123) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceWriteSfd(1419U, -456) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceReadSfd(900U, &value) == PLC_DEVICE_OK);
    TEST_CHECK(value == 123);
    TEST_CHECK(PlcDeviceReadSfd(1419U, &value) == PLC_DEVICE_OK);
    TEST_CHECK(value == -456);
    TEST_CHECK(PlcDeviceReadSfd(899U, &value) == PLC_DEVICE_INVALID_ADDRESS);
    TEST_CHECK(PlcDeviceReadSfd(1420U, &value) == PLC_DEVICE_INVALID_ADDRESS);
    TEST_CHECK(PlcDeviceIsSfdDirty() != 0U);
    TEST_CHECK(PlcDeviceSaveSfd() == PLC_DEVICE_NOT_IMPLEMENTED);
}

static void TestSmAndSd(void)
{
    uint8_t state;
    int32_t value;

    TEST_CHECK(PlcDevicePublishSm(2U, 1U, 0U) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceReadSm(1040U, &state) == PLC_DEVICE_OK);
    TEST_CHECK(state == 1U);
    TEST_CHECK(PlcDeviceReadSm(1041U, &state) == PLC_DEVICE_OK);
    TEST_CHECK(state == 0U);
    TEST_CHECK(PlcDeviceWriteSm(1040U, 0U) == PLC_DEVICE_READ_ONLY);
    TEST_CHECK(PlcDeviceReadSm(1042U, &state) == PLC_DEVICE_INVALID_ADDRESS);

    TEST_CHECK(PlcDevicePublishSd(3U, 11U, -12345) == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceReadSd(1071U, &value) == PLC_DEVICE_OK);
    TEST_CHECK(value == -12345);
    TEST_CHECK(PlcDeviceWriteSd(1071U, 0) == PLC_DEVICE_READ_ONLY);
    TEST_CHECK(PlcDeviceReadSd(1012U, &value) == PLC_DEVICE_INVALID_ADDRESS);
    TEST_CHECK(PlcDevicePublishSd(4U, 0U, 0) == PLC_DEVICE_INVALID_ARGUMENT);

    TEST_CHECK(PlcDeviceInit() == PLC_DEVICE_OK);
    TEST_CHECK(PlcDeviceReadSm(1040U, &state) == PLC_DEVICE_OK);
    TEST_CHECK(state == 0U);
    TEST_CHECK(PlcDeviceReadSd(1071U, &value) == PLC_DEVICE_OK);
    TEST_CHECK(value == 0);
}

int main(void)
{
    TestAddressMap();
    TestHsdAndPersistence();
    TestSfd();
    TestSmAndSd();

    (void)printf("PASS: %u checks\n", TestCount);
    return EXIT_SUCCESS;
}