#include <uacpi/internal/stdlib.h>
#include <uacpi/internal/utilities.h>

#ifdef UACPI_USE_BUILTIN_STRING

#ifndef uacpi_memcpy
void *uacpi_memcpy(void *dest, const void *src, uacpi_size count)
{
    uacpi_char *cd = dest;
    const uacpi_char *cs = src;

    while (count--)
        *cd++ = *cs++;

    return dest;
}
#endif

#ifndef uacpi_memmove
void *uacpi_memmove(void *dest, const void *src, uacpi_size count)
{
    uacpi_char *cd = dest;
    const uacpi_char *cs = src;

    if (src < dest) {
        cs += count;
        cd += count;

        while (count--)
            *--cd = *--cs;
    } else {
        while (count--)
            *cd++ = *cs++;
    }

    return dest;
}
#endif

#ifndef uacpi_memset
void *uacpi_memset(void *dest, uacpi_i32 ch, uacpi_size count)
{
    uacpi_u8 fill = ch;
    uacpi_u8 *cdest = dest;

    while (count--)
        *cdest++ = fill;

    return dest;
}
#endif

#ifndef uacpi_memcmp
uacpi_i32 uacpi_memcmp(const void *lhs, const void *rhs, uacpi_size count)
{
    const uacpi_u8 *byte_lhs = lhs;
    const uacpi_u8 *byte_rhs = rhs;
    uacpi_size i;

    for (i = 0; i < count; ++i) {
        if (byte_lhs[i] != byte_rhs[i])
            return byte_lhs[i] - byte_rhs[i];
    }

    return 0;
}
#endif

#endif // UACPI_USE_BUILTIN_STRING

#ifndef uacpi_strlen
uacpi_size uacpi_strlen(const uacpi_char *str)
{
    const uacpi_char *str1;

    for (str1 = str; *str1; str1++);

    return str1 - str;
}
#endif

#ifndef UACPI_BAREBONES_MODE

#ifndef uacpi_strnlen
uacpi_size uacpi_strnlen(const uacpi_char *str, uacpi_size max)
{
    const uacpi_char *str1;

    for (str1 = str; max-- && *str1; str1++);

    return str1 - str;
}
#endif

#ifndef uacpi_strcmp
uacpi_i32 uacpi_strcmp(const uacpi_char *lhs, const uacpi_char *rhs)
{
    uacpi_size i = 0;
    typedef const uacpi_u8 *cucp;

    while (lhs[i] && rhs[i]) {
        if (lhs[i] != rhs[i])
            return *(cucp)&lhs[i] - *(cucp)&rhs[i];

        i++;
    }

    return *(cucp)&lhs[i] - *(cucp)&rhs[i];
}
#endif

void uacpi_memcpy_zerout(void *dst, const void *src,
    uacpi_size dst_size, uacpi_size src_size)
{
    uacpi_size bytes_to_copy = UACPI_MIN(src_size, dst_size);

    if (bytes_to_copy)
        uacpi_memcpy(dst, src, bytes_to_copy);

    if (dst_size > bytes_to_copy)
        uacpi_memzero((uacpi_u8 *)dst + bytes_to_copy, dst_size - bytes_to_copy);
}

uacpi_u8 uacpi_bit_scan_forward(uacpi_u64 value)
{
#if defined(_MSC_VER) && !defined(__clang__)
    unsigned char ret;
    unsigned long index;

#ifdef _WIN64
    ret = _BitScanForward64(&index, value);
    if (ret == 0)
        return 0;

    return (uacpi_u8)index + 1;
#else
    ret = _BitScanForward(&index, value);
    if (ret == 0) {
        ret = _BitScanForward(&index, value >> 32);
        if (ret == 0)
            return 0;

        return (uacpi_u8)index + 33;
    }

    return (uacpi_u8)index + 1;
#endif

#elif defined(__WATCOMC__)
    // TODO: Use compiler intrinsics or inline ASM here
    uacpi_u8 index;
    uacpi_u64 mask = 1;

    for (index = 1; index <= 64; index++, mask <<= 1) {
        if (value & mask) {
            return index;
        }
    }

    return 0;
#else
    return __builtin_ffsll(value);
#endif
}

uacpi_u8 uacpi_bit_scan_backward(uacpi_u64 value)
{
#if defined(_MSC_VER) && !defined(__clang__)
    unsigned char ret;
    unsigned long index;

#ifdef _WIN64
    ret = _BitScanReverse64(&index, value);
    if (ret == 0)
        return 0;

    return (uacpi_u8)index + 1;
#else
    ret = _BitScanReverse(&index, value >> 32);
    if (ret == 0) {
        ret = _BitScanReverse(&index, value);
        if (ret == 0)
            return 0;

        return (uacpi_u8)index + 1;
    }

    return (uacpi_u8)index + 33;
#endif

#elif defined(__WATCOMC__)
    // TODO: Use compiler intrinsics or inline ASM here
    uacpi_u8 index;
    uacpi_u64 mask = (1ull << 63);

    for (index = 64; index > 0; index--, mask >>= 1) {
        if (value & mask) {
            return index;
        }
    }

    return 0;
#else
    if (value == 0)
        return 0;

    return 64 - __builtin_clzll(value);
#endif
}

#ifndef UACPI_NATIVE_ALLOC_ZEROED
void *uacpi_builtin_alloc_zeroed(uacpi_size size)
{
    void *ptr;

    ptr = uacpi_kernel_alloc(size);
    if (uacpi_unlikely(ptr == UACPI_NULL))
        return ptr;

    uacpi_memzero(ptr, size);
    return ptr;
}
#endif

#endif // !UACPI_BAREBONES_MODE

#ifndef uacpi_vsnprintf
struct fmt_buf_state {
    uacpi_char *buffer;
    uacpi_size capacity;
    uacpi_size bytes_written;
};

struct fmt_spec {
    uacpi_u8 is_signed      : 1;
    uacpi_u8 prepend        : 1;
    uacpi_u8 uppercase      : 1;
    uacpi_u8 left_justify   : 1;
    uacpi_u8 alternate_form : 1;
    uacpi_u8 has_precision  : 1;
    uacpi_char pad_char;
    uacpi_char prepend_char;
    uacpi_u64 min_width;
    uacpi_u64 precision;
    uacpi_u32 base;
};

static void write_one(struct fmt_buf_state *fb_state, uacpi_char c)
{
    if (fb_state->bytes_written < fb_state->capacity)
        fb_state->buffer[fb_state->bytes_written] = c;

    fb_state->bytes_written++;
}

static void write_many(
    struct fmt_buf_state *fb_state, const uacpi_char *string, uacpi_size count
)
{
    if (fb_state->bytes_written < fb_state->capacity) {
        uacpi_size count_to_write;

        count_to_write = UACPI_MIN(
            count, fb_state->capacity - fb_state->bytes_written
        );
        uacpi_memcpy(
            &fb_state->buffer[fb_state->bytes_written], string, count_to_write
        );
    }

    fb_state->bytes_written += count;
}

static uacpi_char hex_char(uacpi_bool upper, uacpi_u64 value)
{
    static const uacpi_char upper_hex[] = "0123456789ABCDEF";
    static const uacpi_char lower_hex[] = "0123456789abcdef";

    return (upper ? upper_hex : lower_hex)[value];
}

static void write_padding(
    struct fmt_buf_state *fb_state, struct fmt_spec *fm, uacpi_size repr_size
)
{
    uacpi_u64 mw = fm->min_width;

    if (mw <= repr_size)
        return;

    mw -= repr_size;

    while (mw--)
        write_one(fb_state, fm->left_justify ? ' ' : fm->pad_char);
}

#define REPR_BUFFER_SIZE 32

static void write_integer(
    struct fmt_buf_state *fb_state, struct fmt_spec *fm, uacpi_u64 value
)
{
    uacpi_char repr_buffer[REPR_BUFFER_SIZE];
    uacpi_size index = REPR_BUFFER_SIZE;
    uacpi_u64 remainder;
    uacpi_char repr;
    uacpi_bool negative = UACPI_FALSE;
    uacpi_size repr_size;

    if (fm->is_signed) {
        uacpi_i64 as_ll = value;

        if (as_ll < 0) {
            value = -as_ll;
            negative = UACPI_TRUE;
        }
    }

    if (fm->prepend || negative)
        write_one(fb_state, negative ? '-' : fm->prepend_char);

    while (value) {
        remainder = value % fm->base;
        value /= fm->base;

        if (fm->base == 16) {
            repr = hex_char(fm->uppercase, remainder);
        } else if (fm->base == 8 || fm->base == 10) {
            repr = remainder + '0';
        } else {
            repr = '?';
        }

        repr_buffer[--index] = repr;
    }
    repr_size = REPR_BUFFER_SIZE - index;

    if (repr_size == 0) {
        repr_buffer[--index] = '0';
        repr_size = 1;
    }

    if (fm->alternate_form) {
        if (fm->base == 16) {
            repr_buffer[--index] = fm->uppercase ? 'X' : 'x';
            repr_buffer[--index] = '0';
            repr_size += 2;
        } else if (fm->base == 8) {
            repr_buffer[--index] = '0';
            repr_size += 1;
        }
    }

    if (fm->left_justify) {
        write_many(fb_state, &repr_buffer[index], repr_size);
        write_padding(fb_state, fm, repr_size);
    } else {
        write_padding(fb_state, fm, repr_size);
        write_many(fb_state, &repr_buffer[index], repr_size);
    }
}

static uacpi_bool string_has_at_least(
    const uacpi_char *string, uacpi_size characters
)
{
    while (*string) {
        if (--characters == 0)
            return UACPI_TRUE;

        string++;
    }

    return UACPI_FALSE;
}

static uacpi_bool consume_digits(
    const uacpi_char **string, uacpi_size *out_size
)
{
    uacpi_size size = 0;

    for (;;) {
        char c = **string;
        if (c < '0' || c > '9')
            break;

        size++;
        *string += 1;
    }

    if (size == 0)
        return UACPI_FALSE;

    *out_size = size;
    return UACPI_TRUE;
}

enum parse_number_mode {
    PARSE_NUMBER_MODE_MAYBE,
    PARSE_NUMBER_MODE_MUST,
};

static uacpi_bool parse_number(
    const uacpi_char **fmt, enum parse_number_mode mode, uacpi_u64 *out_value
)
{
    uacpi_status ret;
    uacpi_size num_digits;
    const uacpi_char *digits = *fmt;

    if (!consume_digits(fmt, &num_digits))
        return mode != PARSE_NUMBER_MODE_MUST;

    ret = uacpi_string_to_integer(digits, num_digits, UACPI_BASE_DEC, out_value);
    return ret == UACPI_STATUS_OK;
}

static uacpi_bool consume(const uacpi_char **string, const uacpi_char *token)
{
    uacpi_size token_size;

    token_size = uacpi_strlen(token);

    if (!string_has_at_least(*string, token_size))
        return UACPI_FALSE;

    if (!uacpi_memcmp(*string, token, token_size)) {
        *string += token_size;
        return UACPI_TRUE;
    }

    return UACPI_FALSE;
}

static uacpi_bool is_one_of(uacpi_char c, const uacpi_char *list)
{
    for (; *list; list++) {
        if (c == *list)
            return UACPI_TRUE;
    }

    return UACPI_FALSE;
}

static uacpi_bool consume_one_of(
    const uacpi_char **string, const uacpi_char *list, uacpi_char *consumed_char
)
{
    uacpi_char c = **string;
    if (!c)
        return UACPI_FALSE;

    if (is_one_of(c, list)) {
        *consumed_char = c;
        *string += 1;
        return UACPI_TRUE;
    }

    return UACPI_FALSE;
}

static uacpi_u32 base_from_specifier(uacpi_char specifier)
{
    switch (specifier)
    {
        case 'x':
        case 'X':
            return 16;
        case 'o':
            return 8;
        default:
            return 10;
    }
}

static uacpi_bool is_uppercase_specifier(uacpi_char specifier)
{
    return specifier == 'X';
}

static const uacpi_char *find_next_conversion(
    const uacpi_char *fmt, uacpi_size *offset
)
{
    *offset = 0;

    while (*fmt) {
        if (*fmt == '%')
            return fmt;

        fmt++;
        *offset += 1;
    }

    return UACPI_NULL;
}

uacpi_i32 uacpi_vsnprintf(
    uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt,
    uacpi_va_list vlist
)
{
    struct fmt_buf_state fb_state = { 0 };
    uacpi_u64 value;
    const uacpi_char *next_conversion;
    uacpi_size next_offset;
    uacpi_char flag;

    fb_state.buffer = buffer;
    fb_state.capacity = capacity;
    fb_state.bytes_written = 0;

    while (*fmt) {
        struct fmt_spec fm = {
            .pad_char = ' ',
            .base = 10,
        };
        next_conversion = find_next_conversion(fmt, &next_offset);

        if (next_offset)
            write_many(&fb_state, fmt, next_offset);

        if (!next_conversion)
            break;

        fmt = next_conversion;
        if (consume(&fmt, "%%")) {
            write_one(&fb_state, '%');
            continue;
        }

        // consume %
        fmt++;

        while (consume_one_of(&fmt, "+- 0#", &flag)) {
            switch (flag) {
            case '+':
            case ' ':
                fm.prepend = UACPI_TRUE;
                fm.prepend_char = flag;
                continue;
            case '-':
                fm.left_justify = UACPI_TRUE;
                continue;
            case '0':
                fm.pad_char = '0';
                continue;
            case '#':
                fm.alternate_form = UACPI_TRUE;
                continue;
            default:
                return -1;
            }
        }

        if (consume(&fmt, "*")) {
            fm.min_width = uacpi_va_arg(vlist, int);
        } else if (!parse_number(&fmt, PARSE_NUMBER_MODE_MAYBE, &fm.min_width)) {
            return -1;
        }

        if (consume(&fmt, ".")) {
            fm.has_precision = UACPI_TRUE;

            if (consume(&fmt, "*")) {
                fm.precision = uacpi_va_arg(vlist, int);
            } else {
                if (!parse_number(&fmt, PARSE_NUMBER_MODE_MUST, &fm.precision))
                    return -1;
            }
        }

        flag = 0;

        if (consume(&fmt, "c")) {
            uacpi_char c = uacpi_va_arg(vlist, int);
            write_one(&fb_state, c);
            continue;
        }

        if (consume(&fmt, "s")) {
            const uacpi_char *string = uacpi_va_arg(vlist, uacpi_char*);
            uacpi_size i;

            if (uacpi_unlikely(string == UACPI_NULL))
                string = "<null>";

            for (i = 0; (!fm.has_precision || i < fm.precision) && string[i]; ++i)
                write_one(&fb_state, string[i]);
            while (i++ < fm.min_width)
                write_one(&fb_state, ' ');
            continue;
        }

        if (consume(&fmt, "p")) {
            value = (uacpi_uintptr)uacpi_va_arg(vlist, void*);
            fm.base = 16;
            fm.min_width = UACPI_POINTER_SIZE * 2;
            fm.pad_char = '0';
            goto write_int;
        }

        if (consume(&fmt, "hh")) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = (signed char)uacpi_va_arg(vlist, int);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = (unsigned char)uacpi_va_arg(vlist, int);
            } else {
                return -1;
            }
            goto write_int;
        }

        if (consume(&fmt, "h")) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = (signed short)uacpi_va_arg(vlist, int);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = (unsigned short)uacpi_va_arg(vlist, int);
            } else {
                return -1;
            }
            goto write_int;
        }

        if (consume(&fmt, "ll") ||
            (sizeof(uacpi_size) == sizeof(long long) && consume(&fmt, "z"))) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = uacpi_va_arg(vlist, long long);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = uacpi_va_arg(vlist, unsigned long long);
            } else {
                return -1;
            }
            goto write_int;
        }

        if (consume(&fmt, "l") ||
            (sizeof(uacpi_size) == sizeof(long) && consume(&fmt, "z"))) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = uacpi_va_arg(vlist, long);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = uacpi_va_arg(vlist, unsigned long);
            } else {
                return -1;
            }
            goto write_int;
        }

        if (consume(&fmt, "d") || consume(&fmt, "i")) {
            value = uacpi_va_arg(vlist, uacpi_i32);
            fm.is_signed = UACPI_TRUE;
        } else if (consume_one_of(&fmt, "oxXu", &flag)) {
            value = uacpi_va_arg(vlist, uacpi_u32);
        } else {
            return -1;
        }

    write_int:
        if (flag != 0) {
            fm.base = base_from_specifier(flag);
            fm.uppercase = is_uppercase_specifier(flag);
        }

        write_integer(&fb_state, &fm, value);
    }

    if (fb_state.capacity) {
        uacpi_size last_char;

        last_char = UACPI_MIN(fb_state.bytes_written, fb_state.capacity - 1);
        fb_state.buffer[last_char] = '\0';
    }

    return fb_state.bytes_written;
}
#endif

#ifndef uacpi_snprintf
uacpi_i32 uacpi_snprintf(
    uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt, ...
)
{
    uacpi_va_list vlist;
    uacpi_i32 ret;

    uacpi_va_start(vlist, fmt);
    ret = uacpi_vsnprintf(buffer, capacity, fmt, vlist);
    uacpi_va_end(vlist);

    return ret;
}
#endif

#ifndef UACPI_FORMATTED_LOGGING
void uacpi_log(uacpi_log_level lvl, const uacpi_char *str, ...)
{
    uacpi_char buf[UACPI_PLAIN_LOG_BUFFER_SIZE];
    int ret;

    uacpi_va_list vlist;
    uacpi_va_start(vlist, str);

    ret = uacpi_vsnprintf(buf, sizeof(buf), str, vlist);
    if (uacpi_unlikely(ret < 0))
        return;

    /*
     * If this log message is too large for the configured buffer size, cut off
     * the end and transform into "...\n" to indicate that it didn't fit and
     * prevent the newline from being truncated.
     */
    if (uacpi_unlikely(ret >= UACPI_PLAIN_LOG_BUFFER_SIZE)) {
        buf[UACPI_PLAIN_LOG_BUFFER_SIZE - 5] = '.';
        buf[UACPI_PLAIN_LOG_BUFFER_SIZE - 4] = '.';
        buf[UACPI_PLAIN_LOG_BUFFER_SIZE - 3] = '.';
        buf[UACPI_PLAIN_LOG_BUFFER_SIZE - 2] = '\n';
    }

    uacpi_kernel_log(lvl, buf);

    uacpi_va_end(vlist);
}
#endif
