#include <stddef.h>
#include "inttypes.h"
#include "memory.h"

void memset(char *ptr, char value, int len) {
  int i;
  assert(ptr != NULL);
  for (i = 0; i < len; i++) {
    ptr[i] = value;
  }
}

void *memmove(void *dest, const void *src, uint32_t n) {
  assert(dest != NULL && src != NULL);
  
  char *pDest = (char *)dest;
  const char *pSrc = (const char *)src;
  // allocate memory for tmp array
  char *tmp = (char *)dbmalloc(sizeof(char) * n, "memmove");
  if (NULL == tmp) {
    return NULL;
  } else {
    uint32_t i = 0;
    // copy src to tmp array
    for (i = 0; i < n; ++i) {
      *(tmp + i) = *(pSrc + i);
    }
    // copy tmp to dest
    for (i = 0; i < n; ++i) {
      *(pDest + i) = *(tmp + i);
    }
    free(tmp); // free allocated memory
  }
  return dest;
}

void memcpy(void *dest, void *src, int size) {
  assert(dest != NULL && src != NULL);
  uint8_t *pdest = (uint8_t *)dest;
  uint8_t *psrc = (uint8_t *)src;

  int loops = (size / sizeof(uint32_t));
  for (int index = 0; index < loops; ++index) {
    *((uint32_t *)pdest) = *((uint32_t *)psrc);
    pdest += sizeof(uint32_t);
    psrc += sizeof(uint32_t);
  }

  loops = (size % sizeof(uint32_t));
  for (int index = 0; index < loops; ++index) {
    *pdest = *psrc;
    ++pdest;
    ++psrc;
  }
}

char *strncpy(char *dest, const char *src, int len) {
  assert(dest != NULL && src != NULL);
  const char *ptr = src;
  char *ptr2 = dest;
  int i = 0;
  while (*ptr != '\0' && i != len) {
    *ptr2 = *ptr;
    if (i < len - 1) {
      *(ptr2 + 1) = '\0';
    }
    ptr2++;
    ptr++;
    i++;
  }
  return dest;
}

char *strcpy(char *dest, const char *src) {
  assert(dest != NULL && src != NULL);
  const char *ptr = src;
  char *ptr2 = dest;
  while (*ptr != '\0') {
    *ptr2 = *ptr;
    *(ptr2 + 1) = '\0';
    ptr2++;
    ptr++;
  }
  return dest;
}

int memcmp(const uint8_t *m1, const uint8_t *m2, int size) {

  assert(m1 != NULL && m2 != NULL);

  while ((*m1) && (*m1 == *m2) && size > 0) {
    --size;
    ++m1;
    ++m2;
  }
  return (*m1 - *m2);
}

int strncmp(const char *s1, const char *s2, int n) {
  assert(s1 != NULL && s2 != NULL);
 
  while ((*s1) && (*s1 == *s2) && n > 0) {
    --n;
    ++s1;
    ++s2;
  }
  return (*s1 - *s2);
}

int strcmp(const char *s1, const char *s2) {
  assert(s1 != NULL && s2 != NULL);

  while ((*s1) && (*s1 == *s2)) {
    ++s1;
    ++s2;
  }
  return (*s1 - *s2);
}

int strlen(const char *str) {
  int i = 0;

  assert(str != NULL);

  while (*str != '\0') {
    str++;
    i++;
  }
  return i;
}

char *strcat(char *dest, const char *src) {
  assert(dest != NULL && src != NULL);
  char *ptr = dest;
  while (*dest != '\0') {
    dest++;
  }

  while (*src != '\0') {
    *dest = *src;
    dest++;
    *dest = '\0';
    src++;
  }
  return ptr;
}

char toupper(char c) {
  if (c > 64 && c < 91) {
    return c;
  } else {
    return c - 32;
  }
}