#include <errno.h>
#include <stdlib.h>
#include <string.h>

extern "C"
{
    void* memcpy(void* dest, const void* src, size_t n)
    {
        for (size_t i = 0; i < n; ++i) { *((char*)dest + i) = *((const char*)src + i); }
        return dest;
    }

    void* memset(void* buf, int c, size_t n)
    {
        for (size_t i = 0; i < n; ++i) { *((char*)buf + i) = (char)c; }
        return buf;
    }

    void* memchr(const void* buf, int c, size_t n)
    {
        const char* s = (const char*)buf;
        for (; n && *s != (char)c; s++, n--)
            ;
        if (n) return (void*)(const_cast<char*>(s));
        return NULL;
    }

    int memcmp(const void* a, const void* b, size_t n)
    {
        const char* _a = (const char*)a;
        const char* _b = (const char*)b;
        for (; n && _a == _b; n--, _a++, _b++)
            ;
        if (!n) return 0;
        if (*_a > *_b) return 1;
        return -1;
    }

    void* memmove(void* dest, const void* src, size_t n)
    {
        if (dest == src) return dest;
        if (dest > src)
            for (long i = n - 1; i >= 0; i++) { *((char*)dest + i) = *((char*)src + i); }
        else
            for (long i = 0; i < (long)n; i++) { *((char*)dest + i) = *((char*)src + i); }
        return dest;
    }

    char* strdup(const char* str)
    {
        size_t len = strlen(str);
        char* dest = (char*)malloc(len + 1);
        if (!dest) return dest;
        return (char*)memcpy(dest, str, len + 1);
    }

    size_t strlen(const char* str)
    {
        const char* i = str;
        for (; *i; ++i)
            ;
        return (i - str);
    }

    size_t strnlen(const char* str, size_t max)
    {
        char* p = (char*)memchr(str, 0, max);
        return p ? p - str : max;
    }

    char* strcpy(char* dest, const char* src)
    {
        memcpy(dest, src, strlen(src) + 1);
        return dest;
    }

    char* strncpy(char* dest, const char* src, size_t max) // FIXME: Implement strncpy according to the specification.
    {
        size_t src_len = strlen(src) + 1; // NULL byte
        memcpy(dest, src, src_len > max ? max : src_len);
        return dest;
    }

    char* strcat(char* dest, const char* src)
    {
        size_t dest_len = strlen(dest);
        size_t i;

        for (i = 0; *(src + i); i++) *(char*)(dest + dest_len + i) = *(const char*)(src + i);

        *(char*)(dest + dest_len + i) = '\0';

        return dest;
    }

    char* strncat(char* dest, const char* src, size_t max)
    {
        size_t dest_len = strlen(dest);
        size_t i;

        for (i = 0; i < max && *(src + i); i++) *(char*)(dest + dest_len + i) = *(const char*)(src + i);

        *(char*)(dest + dest_len + i) = '\0';

        return dest;
    }

    char* strchr(const char* str, int c)
    {
        while (*str && *str != (char)c) str++;
        if (*str) return const_cast<char*>(str);
        return NULL;
    }

    void* bzero(void* buf, size_t n)
    {
        return memset(buf, 0, n);
    }

#pragma GCC push_options
#pragma GCC diagnostic ignored "-Wwrite-strings"

    char* strerror(int err)
    {
        switch (err)
        {
        case EPERM: return "Operation not permitted";
        case EINVAL: return "Invalid argument";
        case ENOMEM: return "Cannot allocate memory";
        case ENOSYS: return "Function not implemented";
        case ENOENT: return "No such file or directory";
        case EBADF: return "Bad file descriptor";
        case EMFILE: return "Too many open files";
        case EISDIR: return "Is a directory";
        case ENOEXEC: return "Exec format error";
        case EFAULT: return "Bad address";
        case 0: return "Success";
        default: return (char*)(unsigned long int)err;
        }
    }

#pragma GCC pop_options
}