#include <libk/fieldlengthof.h>
#include <libk/hash.h>
#include <libk/lengthof.h>
#include <libk/minmax.h>
#include <libk/std.h>
#include <libk/string.h>
#include <mm/malloc.h>
#include <proc/env.h>
#include <proc/procgroup.h>
#include <status.h>

void proc_env_cleanup (struct procgroup* procgroup) {
  for (size_t i = 0; i < fieldlengthof (struct proc_env, env_var_buckets); i++) {
    struct hash_node_link* link = procgroup->env.env_var_buckets[i];

    if (link == NULL)
      continue;

    struct proc_env_var* var = hash_entry (link, struct proc_env_var, env_link);

    free (var->buffer);
    free (var);
  }
}

int proc_env_set (struct procgroup* procgroup, const char* key, void* buffer, size_t data_size) {
  uint64_t fpg;

  struct proc_env_var* var = malloc (sizeof (*var));

  if (var == NULL)
    return -ST_OOM_ERROR;

  memset (var, 0, sizeof (*var));

  var->buffer = malloc (data_size);

  if (var->buffer == NULL) {
    free (var);
    return -ST_OOM_ERROR;
  }

  var->data_size = data_size;
  memcpy (var->key, key, strlen_null (key));
  memcpy (var->buffer, buffer, data_size);

  uint32_t env_hash = hash_fnv32 (var->key, strlen_null (var->key));

  spin_lock (&procgroup->lock, &fpg);

  hash_insert (&procgroup->env, &var->env_link, env_hash, lengthof (procgroup->env.env_var_buckets),
               env_var_buckets);

  spin_unlock (&procgroup->lock, fpg);

  return ST_OK;
}

int proc_env_get (struct procgroup* procgroup, const char* key, void* buffer, size_t size) {
  uint64_t fpg;

  struct hash_node_link* found_link = NULL;
  size_t key_len = strlen_null (key);
  uint32_t hash = hash_fnv32 (key, key_len);

  spin_lock (&procgroup->lock, &fpg);

  hash_find (&procgroup->env, key, key_len, hash, lengthof (procgroup->env.env_var_buckets),
             env_var_buckets, struct proc_env_var, env_link, key, found_link);

  if (found_link == NULL) {
    spin_unlock (&procgroup->lock, fpg);
    return -ST_NOT_FOUND;
  }

  struct proc_env_var* var = hash_entry (found_link, struct proc_env_var, env_link);

  memcpy (buffer, var->buffer, min (size, var->data_size));

  spin_unlock (&procgroup->lock, fpg);

  return ST_OK;
}