#include <assert.h>
#include <stdio.h>
#include <string.h>

#include "maze32_wifi_config.h"

typedef struct {
    int guard_result;
    int guard_calls;
    int save_calls;
    int clear_calls;
    maze32_wifi_credentials_t saved;
} fixture_t;

static int guard(void *context)
{
    fixture_t *fixture = context;
    ++fixture->guard_calls;
    return fixture->guard_result;
}

static int save(const maze32_wifi_credentials_t *credentials, void *context)
{
    fixture_t *fixture = context;
    ++fixture->save_calls;
    fixture->saved = *credentials;
    return 0;
}

static int clear(void *context)
{
    fixture_t *fixture = context;
    ++fixture->clear_calls;
    return 0;
}

static maze32_wifi_credentials_t valid_credentials(void)
{
    maze32_wifi_credentials_t credentials = {0};
    memcpy(credentials.ssid, "Labyrinth", sizeof("Labyrinth"));
    memcpy(credentials.password, "eight888", sizeof("eight888"));
    return credentials;
}

static void test_validation_boundaries(void)
{
    maze32_wifi_credentials_t credentials = valid_credentials();
    assert(maze32_wifi_credentials_validate(&credentials) == MAZE32_WIFI_CONFIG_VALID);

    credentials.password[0] = '\0';
    assert(maze32_wifi_credentials_validate(&credentials) == MAZE32_WIFI_CONFIG_VALID);

    memcpy(credentials.password, "short", sizeof("short"));
    assert(maze32_wifi_credentials_validate(&credentials) ==
           MAZE32_WIFI_CONFIG_INVALID_PASSWORD);

    credentials = valid_credentials();
    credentials.ssid[0] = '\0';
    assert(maze32_wifi_credentials_validate(&credentials) == MAZE32_WIFI_CONFIG_INVALID_SSID);

    memset(credentials.ssid, 's', sizeof(credentials.ssid));
    assert(maze32_wifi_credentials_validate(&credentials) == MAZE32_WIFI_CONFIG_INVALID_SSID);

    credentials = valid_credentials();
    credentials.ssid[2] = '\n';
    assert(maze32_wifi_credentials_validate(&credentials) == MAZE32_WIFI_CONFIG_INVALID_SSID);
}

static void test_invalid_input_never_mutates_storage(void)
{
    fixture_t fixture = {0};
    maze32_wifi_credentials_t credentials = valid_credentials();
    credentials.password[0] = 'x';
    credentials.password[1] = '\0';
    assert(maze32_wifi_config_apply(&credentials, guard, save, &fixture) == -1);
    assert(fixture.guard_calls == 0);
    assert(fixture.save_calls == 0);
}

static void test_guard_precedes_every_mutation(void)
{
    fixture_t fixture = {.guard_result = -1};
    maze32_wifi_credentials_t credentials = valid_credentials();
    assert(maze32_wifi_config_apply(&credentials, guard, save, &fixture) == -2);
    assert(fixture.guard_calls == 1);
    assert(fixture.save_calls == 0);
    assert(maze32_wifi_config_reset(guard, clear, &fixture) == -2);
    assert(fixture.guard_calls == 2);
    assert(fixture.clear_calls == 0);
}

static void test_valid_apply_and_reset(void)
{
    fixture_t fixture = {0};
    maze32_wifi_credentials_t credentials = valid_credentials();
    assert(maze32_wifi_config_apply(&credentials, guard, save, &fixture) == 0);
    assert(fixture.guard_calls == 1);
    assert(fixture.save_calls == 1);
    assert(strcmp(fixture.saved.ssid, credentials.ssid) == 0);
    assert(strcmp(fixture.saved.password, credentials.password) == 0);

    assert(maze32_wifi_config_reset(guard, clear, &fixture) == 0);
    assert(fixture.guard_calls == 2);
    assert(fixture.clear_calls == 1);
}

int main(void)
{
    test_validation_boundaries();
    test_invalid_input_never_mutates_storage();
    test_guard_precedes_every_mutation();
    test_valid_apply_and_reset();
    puts("wifi configuration tests: PASS");
    return 0;
}