/*
 * SPDX-FileCopyrightText: 2025 Kozmotronik Tech
 *
 * SPDX-License-Identifier: MIT
 */

#include <string.h>
#include "unity.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "relay_chn_nvs.h"


TEST_CASE("Test relay storage init/deinit", "[relay_chn][nvs]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test direction setting and getting", "[relay_chn][nvs]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    // Test channel 0
    TEST_ESP_OK(relay_chn_nvs_set_direction(0, RELAY_CHN_DIRECTION_DEFAULT));
    relay_chn_direction_t dir;
    TEST_ESP_OK(relay_chn_nvs_get_direction(0, &dir));
    TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_DEFAULT, dir);
    
    // Test channel 1
    TEST_ESP_OK(relay_chn_nvs_set_direction(0, RELAY_CHN_DIRECTION_FLIPPED));
    TEST_ESP_OK(relay_chn_nvs_get_direction(0, &dir));
    TEST_ASSERT_EQUAL(RELAY_CHN_DIRECTION_FLIPPED, dir);
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test invalid parameters", "[relay_chn][nvs]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    // Test NULL pointer
    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_nvs_get_direction(0, NULL));
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test relay_chn_nvs_erase_all", "[relay_chn][nvs]")
{
    TEST_ESP_OK(relay_chn_nvs_init());

    // Store some test data first
    relay_chn_direction_t direction = RELAY_CHN_DIRECTION_FLIPPED;
    TEST_ESP_OK(relay_chn_nvs_set_direction(0, direction));

#ifdef RELAY_CHN_ENABLE_TILTING
    uint8_t sensitivity = 50;
    TEST_ESP_OK(relay_chn_nvs_set_tilt_sensitivity(0, sensitivity));
    TEST_ESP_OK(relay_chn_nvs_set_tilt_count(0, 100));
#endif

    // Test erase all
    TEST_ESP_OK(relay_chn_nvs_erase_all());

    // Verify data was erased by trying to read it back
    relay_chn_direction_t read_direction;
    TEST_ASSERT_EQUAL(ESP_ERR_NVS_NOT_FOUND, relay_chn_nvs_get_direction(0, &read_direction));

#ifdef RELAY_CHN_ENABLE_TILTING
    uint8_t read_sensitivity;
    TEST_ASSERT_EQUAL(ESP_ERR_NVS_NOT_FOUND, relay_chn_nvs_get_tilt_sensitivity(0, &read_sensitivity));

    uint16_t tilt_count;
    TEST_ASSERT_EQUAL(ESP_ERR_NVS_NOT_FOUND, relay_chn_nvs_get_tilt_count(0, &tilt_count));
#endif

    TEST_ESP_OK(relay_chn_nvs_deinit());
}

#ifdef RELAY_CHN_ENABLE_TILTING
TEST_CASE("Test sensitivity setting and getting", "[relay_chn][nvs][tilt]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    const uint8_t test_sensitivity = 75;
    TEST_ESP_OK(relay_chn_nvs_set_tilt_sensitivity(0, test_sensitivity));
    
    uint8_t sensitivity;
    TEST_ESP_OK(relay_chn_nvs_get_tilt_sensitivity(0, &sensitivity));
    TEST_ASSERT_EQUAL(test_sensitivity, sensitivity);
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test tilt counter operations", "[relay_chn][nvs][tilt]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    const uint16_t tilt_count = 100;
    
    // Test setting counters
    TEST_ESP_OK(relay_chn_nvs_set_tilt_count(0, tilt_count));
    
    uint16_t tilt_count_read;
    TEST_ESP_OK(relay_chn_nvs_get_tilt_count(0, &tilt_count_read));
    TEST_ASSERT_EQUAL(tilt_count, tilt_count_read);
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}

TEST_CASE("Test tilting invalid parameters", "[relay_chn][nvs][tilt]")
{
    TEST_ESP_OK(relay_chn_nvs_init());
    
    // Test NULL pointers
    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_nvs_get_tilt_sensitivity(0, NULL));
    TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, relay_chn_nvs_get_tilt_count(0, NULL));
    
    TEST_ESP_OK(relay_chn_nvs_deinit());
}
#endif // RELAY_CHN_ENABLE_TILTING