#include "../include/nx/software/SystemSettings.h"

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

#define KEY_INIT_FLAG           "sysinit"
#define KEY_WIFI_SSID           "ssid"
#define KEY_WIFI_PASS           "wpass"
#define KEY_WIFI_POWER_SAVE     "wpsave"
#define KEY_WIFI_USE_STATIC     "wstat"
#define KEY_WIFI_ADDR           "waddr"
#define KEY_WIFI_GW             "wgw"
#define KEY_WIFI_MASK           "wmask"
#define KEY_DNS_ADDR            "dns"
#define KEY_SNTP_ADDR           "sntp"
#define KEY_TZ_ENV              "tz"
#define KEY_RS_SCHEDULE         "rsch"

#define IPV4_ADDR_SIZE 4

#define STORAGE_READ(_KEY, _NAME)\
    storageRead(_KEY, &settings._NAME, sizeof(settings._NAME));

#define STORAGE_WRITE(_KEY, _NAME)\
    storageWrite(_KEY, &settings._NAME, sizeof(settings._NAME));

static const uint8_t INIT_FLAG_VALUE = 1;
static const char* DEFAULT_WIFI_SSID = "service_wifi";
static const char* DEFAULT_WIFI_PASS = "service_wifi";
static const bool DEFAULT_WIFI_POWER_SAVE = false;
static const bool DEFAULT_WIFI_USE_STATIC = false;
static const char DEFAULT_WIFI_ADDR[IPV4_ADDR_SIZE] = {192,168,8,101};
static const char DEFAULT_WIFI_GW[IPV4_ADDR_SIZE]   = {192,168,8,1};
static const char DEFAULT_WIFI_MASK[IPV4_ADDR_SIZE] = {255,255,255,0};
static const char DEFAULT_DNS_ADDR[IPV4_ADDR_SIZE] = {8,8,8,8};
static const char* DEFAULT_SNTP_ADDR = "pool.ntp.org";
static const char* DEFAULT_TZ_ENV = "CET-1CEST,M3.5.0,M10.5.0/3";
static const char* DEFAULT_RS_SCHEDULE = "72 23 59 60"; // days (bin), hour, minute, required uptime (min)

static StorageWriteFn storageWrite = NULL;
static StorageReadFn storageRead = NULL;

static SystemSettings settings;

static bool firstRun(void)
{
  uint8_t initFlag = 0;
  if (!storageRead(KEY_INIT_FLAG, &initFlag, sizeof(initFlag))) {
    return true;
  }
  return initFlag != INIT_FLAG_VALUE;
}

static void loadSystemSettings(void)
{
  printf("Loading system settings\n");
  STORAGE_READ(KEY_WIFI_SSID      , wifiSsid     );
  STORAGE_READ(KEY_WIFI_PASS      , wifiPassword );
  STORAGE_READ(KEY_WIFI_POWER_SAVE, wifiPowerSave);
  STORAGE_READ(KEY_WIFI_USE_STATIC, useStaticAddr);
  STORAGE_READ(KEY_WIFI_ADDR      , ip4addr      );
  STORAGE_READ(KEY_WIFI_GW        , ip4gw        );
  STORAGE_READ(KEY_WIFI_MASK      , ip4mask      );
  STORAGE_READ(KEY_DNS_ADDR       , dnsAddr      );
  STORAGE_READ(KEY_SNTP_ADDR      , sntpAddr     );
  STORAGE_READ(KEY_TZ_ENV         , tzEnv        );
  STORAGE_READ(KEY_RS_SCHEDULE    , rsSchedule   );
}


// --------- Public API --------- //

void nxInitSystemSettings(StorageWriteFn writeFn,
    StorageReadFn readFn)
{
  storageWrite = writeFn;
  storageRead = readFn;

  if (firstRun()) {
    printf("FIRST RUN\n");
    nxRestoreSystemDefaultSettings();
  }
  else {
    loadSystemSettings();
  }
}

void nxRestoreSystemDefaultSettings(void)
{
  printf("Restoring DEFAULT system settings\n");
  strcpy(settings.wifiSsid, DEFAULT_WIFI_SSID);
  strcpy(settings.wifiPassword, DEFAULT_WIFI_PASS);
  settings.wifiPowerSave = DEFAULT_WIFI_POWER_SAVE;
  settings.useStaticAddr = DEFAULT_WIFI_USE_STATIC;
  memcpy(settings.ip4addr, DEFAULT_WIFI_ADDR, IPV4_ADDR_SIZE);
  memcpy(settings.ip4gw, DEFAULT_WIFI_GW, IPV4_ADDR_SIZE);
  memcpy(settings.ip4mask, DEFAULT_WIFI_MASK, IPV4_ADDR_SIZE);
  memcpy(settings.dnsAddr, DEFAULT_DNS_ADDR, IPV4_ADDR_SIZE);
  strcpy(settings.sntpAddr, DEFAULT_SNTP_ADDR);
  strcpy(settings.tzEnv, DEFAULT_TZ_ENV);
  strcpy(settings.rsSchedule, DEFAULT_RS_SCHEDULE);

  nxWriteSystemSettings();
}

void nxUpdateSystemSettings(SystemSettings* newSettings)
{
  memcpy(&settings, newSettings, sizeof(SystemSettings));
  nxWriteSystemSettings();
}

void nxWriteSystemSettings(void)
{
  printf("WRITING SYSTEM SETTINGS\n");
  storageWrite(KEY_INIT_FLAG, &INIT_FLAG_VALUE, 1);

  STORAGE_WRITE(KEY_WIFI_SSID      , wifiSsid          );
  STORAGE_WRITE(KEY_WIFI_PASS      , wifiPassword      );
  STORAGE_WRITE(KEY_WIFI_POWER_SAVE, wifiPowerSave     );
  STORAGE_WRITE(KEY_WIFI_USE_STATIC, useStaticAddr     );
  STORAGE_WRITE(KEY_WIFI_ADDR      , ip4addr           );
  STORAGE_WRITE(KEY_WIFI_GW        , ip4gw             );
  STORAGE_WRITE(KEY_WIFI_MASK      , ip4mask           );
  STORAGE_WRITE(KEY_DNS_ADDR       , dnsAddr           );
  STORAGE_WRITE(KEY_SNTP_ADDR      , sntpAddr          );
  STORAGE_WRITE(KEY_TZ_ENV         , tzEnv             );
  STORAGE_WRITE(KEY_RS_SCHEDULE    , rsSchedule        );
}

SystemSettings* nxGetSystemSettings(void)
{
  return &settings;
}