#include <gtest/gtest.h>
#include "app.hpp"
#include <string>
#include <cstring>

using namespace dau;

class DAUTest : public ::testing::Test {
protected:
    void SetUp() override {
        DAU_SetSleep(false);
    }
};

TEST_F(DAUTest, testDAUProcessNormalInput) {
    RawDataFrame input{};
    input.len = 8;
    for(int i=0; i<8; ++i) input.data[i] = i;
    input.timestamp = 12345;
    input.busType = 1;

    ValidData output{};
    std::string errorLog;

    uint32_t initialLoad = DAU_GetBusLoad();
    bool result = DAU_Process(input, output, errorLog);

    EXPECT_TRUE(result);
    EXPECT_EQ(output.dataLen, 8);
    EXPECT_EQ(output.timestamp, 12345);
    EXPECT_EQ(output.sourceBus, 1);
    EXPECT_EQ(DAU_GetBusLoad(), initialLoad + 5);
}

TEST_F(DAUTest, testDAUProcessZeroLength) {
    RawDataFrame input{};
    input.len = 0;
    ValidData output{};
    std::string errorLog;

    bool result = DAU_Process(input, output, errorLog);
    EXPECT_FALSE(result);
    EXPECT_NE(errorLog.find("Invalid data length"), std::string::npos);
}

TEST_F(DAUTest, testDAUProcessMaxLength) {
    RawDataFrame input{};
    input.len = 64;
    for(int i=0; i<64; ++i) input.data[i] = 0x01;
    ValidData output{};
    std::string errorLog;

    bool result = DAU_Process(input, output, errorLog);
    EXPECT_TRUE(result);
    EXPECT_EQ(output.dataLen, 64);
}

TEST_F(DAUTest, testDAUProcessExceedMaxLength) {
    RawDataFrame input{};
    input.len = 65;
    ValidData output{};
    std::string errorLog;

    bool result = DAU_Process(input, output, errorLog);
    EXPECT_FALSE(result);
    EXPECT_NE(errorLog.find("Invalid data length"), std::string::npos);
}

TEST_F(DAUTest, testDAUProcessErrorFrame) {
    RawDataFrame input{};
    input.len = 8;
    memset(input.data, 0xFF, 8);
    ValidData output{};
    std::string errorLog;

    bool result = DAU_Process(input, output, errorLog);
    EXPECT_FALSE(result);
    EXPECT_NE(errorLog.find("Error frame detected"), std::string::npos);
}

TEST_F(DAUTest, testDAUProcessSleepMode) {
    DAU_SetSleep(true);
    RawDataFrame input{};
    input.len = 8;
    ValidData output{};
    std::string errorLog;

    bool result = DAU_Process(input, output, errorLog);
    EXPECT_FALSE(result);
    EXPECT_NE(errorLog.find("Sleep mode"), std::string::npos);
    
    DAU_SetSleep(false);
}

TEST_F(DAUTest, testDAUSetSleepAndGetBusLoad) {
    DAU_SetSleep(false);
    uint32_t load1 = DAU_GetBusLoad();
    
    RawDataFrame input{};
    input.len = 1;
    input.data[0] = 0x01;
    ValidData output{};
    std::string errorLog;
    DAU_Process(input, output, errorLog);
    
    uint32_t load2 = DAU_GetBusLoad();
    EXPECT_EQ(load2, load1 + 5);
}