#include "string.h"
#include "configulator.h"
#include "cfglr_log.h"

#define TAG "CFGLR"

cfglr_handle_t *configulator;

uint8_t cfglr_add_element(cfglr_handle_t *handle, cfglr_element_t *element) {
  cfglr_signaler_t *signaler;

  CFGLR_LOGI(TAG, "Initializing element: %s", element->key);
  CFGLR_LOGI(TAG, "size: %d", element->datatype_size);

  element->handle = handle;

  if(element->data == NULL) {
    element->data = (void*)malloc(element->datatype_size);
    bzero(element->data, 0);
    CFGLR_LOGD(TAG, "malloc: %d @ %p", element->datatype_size, element->data);
  }

  CFGLR_LOGD(TAG, "Initializing %d Signalers", element->signaler_count);

  while((signaler = &element->signalers[element->signaler_count])) {
    if(signaler->init == NULL && signaler->dispatch == NULL) break;

    if(signaler->init != NULL) {
      signaler->init(signaler, element, handle);
    }

    element->signaler_count++;
  }

  cfglr_signal_e signal;

  if(handle->backend.get(&handle->backend, element, handle) == 0) {
    signal = CFGLR_SIGNAL_LOADED;
  } else {
    CFGLR_LOGI(TAG, "failed to load %s, setting default", element->key);

    memcpy((void*)&element->data, (void*)&element->default_data, element->default_size);
    signal = CFGLR_SIGNAL_INIT;

    if(handle->backend.set(&handle->backend, element, handle) != 0) {
      signal = CFGLR_SIGNAL_FAILED;
    }
  }

  for(uint8_t i = 0; i < element->signaler_count; i++) {
    element->signalers[i].dispatch(&element->signalers[i], element, signal);
  }

  return ++handle->element_count;
}

uint8_t cfglr_init(cfglr_handle_t *handle) {
  cfglr_backend_t *backend = &handle->backend;
  cfglr_element_t *element;

  handle->element_count = 0;

  CFGLR_LOGI(TAG, "initializing backend");

  if(backend->open != NULL) {
    CFGLR_LOGI(TAG, "opening backend");
    backend->open(backend, handle);
  }

  CFGLR_LOGI(TAG, "initializing elements");

  while((element = &handle->elements[handle->element_count])) {
    if(element->key == NULL) break;

    cfglr_add_element(handle, element);
  }

  return 0;
}

uint16_t cfglr_commit(cfglr_element_t *element) {
  cfglr_handle_t *handle = element->handle;

  cfglr_commit_data(&handle->backend, element, handle);

  return 0;
}

uint16_t cfglr_commit_data(cfglr_backend_t *backend, cfglr_element_t *element, cfglr_handle_t *handle) {
  uint16_t ret = backend->set(backend, element, handle);

  CFGLR_LOGI(TAG, "commit: %s->%s", handle->namespace, element->key);

  if(ret == 0) {
    for(uint8_t i = 0; i < element->signaler_count; i++) {
      element->signalers[i].dispatch(&element->signalers[i], element, CFGLR_SIGNAL_CHANGE);
    }
  }

  return ret;
}

cfglr_element_t * cfglr_get_element(cfglr_handle_t *handle, const char *name) {
  cfglr_element_t *element;

  uint8_t i = 0;
  for(; i < handle->element_count; i++) {
    element = &handle->elements[i];

    CFGLR_LOGI(TAG, "element: %s @ %p", element->key, element);
    if(strcmp(element->key, name) == 0) return element;
  }

  return NULL;
}