// SPDX-License-Identifier: Apache-2.0
// Copyright 2019 Charles University

#include <adt/list.h>
#include <debug.h>
#include <drivers/printer.h>
#include <lib/print.h>
#include <lib/stdarg.h>
#include <types.h>

static void puts_on_line(const char* s) {
    while (*s != '\0') {
        printer_putchar(*s);
        s++;
    }
}

/** Prints given string to console, terminating it with newline.
 *
 * @param s String to print.
 */
void puts(const char* s) {
    puts_on_line(s);
    printer_putchar('\n');
}

static int abs(int n) {
    if (n < 0) {
        return -n;
    }

    return n;
}

static void printHex(unsigned int n, int konstant) {
    const int numberOffset = 48;
    const int maxLength = 8;
    int digits[maxLength];
    for (int i = 0; i < maxLength; ++i) {
        digits[i] = n % 16;
        n /= 16;
    }

    int first = 0;
    int offset = numberOffset;
    for (int j = maxLength - 1; j > 0; --j) {
        if (first == 1 || digits[j] != 0) {
            first = 1;
            if (digits[j] < 10) {
                offset = numberOffset;
            } else {
                offset = konstant;
            }
            printer_putchar((char)(digits[j] + offset));
        }
    }
    if (digits[0] < 10) {
        offset = numberOffset;
    } else {
        offset = konstant;
    }
    printer_putchar((char)(digits[0] + offset));
}


static void printPointer(void* p) {
    puts_on_line("0x");
    printHex((unsigned int)p, 87);
}

static void print_int(int number) {
    if (number < 0) {
        printer_putchar('-');
    }
    const int maxLength = 10;
    int digits[maxLength];
    for (int i = 0; i < maxLength; ++i) {
        digits[i] = abs(number % 10);
        number /= 10;
    }
    int first = 0;
    for (int j = maxLength - 1; j > 0; --j) {
        if (first == 1 || digits[j] != 0) {
            first = 1;
            printer_putchar((char)(digits[j] + 48));
        }
    }
    printer_putchar((char)(digits[0] + 48));
}

static void printList(list_t* list) {
    printPointer(list);
    printer_putchar('[');
    size_t size = list_get_size(list);
    if (size == 0) {
        puts_on_line("empty");
    } else {
        print_int(size);
        printer_putchar(':');
        printer_putchar(' ');

        link_t* headItem = list->head.next;
        printPointer(headItem);
        link_t* item = headItem->next;
        while (item != &(list->head)) {
            printer_putchar('-');
            printPointer(item);
            item = item->next;
        }
    }
    printer_putchar(']');
}

/** Prints given formatted string to console.
 *
 * @param format printf-style formatting string.
 */
void printk(const char* format, ...) {

    va_list args;
    va_start(args, format);
    const char* it = format;
    while (*it != '\0') {
        if (*it == '%') {
            it++;
            switch (*it) {
            case 'd':
                print_int(va_arg(args, int));
                break;
            case 's':
                puts_on_line(va_arg(args, char*));
                break;
            case 'x':
                printHex(va_arg(args, unsigned int), 87);
                break;
            case 'X':
                printHex(va_arg(args, unsigned int), 55);
                break;
            case 'c':
                printer_putchar(va_arg(args, int));
                break;
            case '%':
                printer_putchar('%');
                break;
            case 'p':
                it++;
                if (*it == 'L') {
                    list_t* argument = va_arg(args, void*);
                    printList(argument);
                } else {
                    it--;
                    void* argument = va_arg(args, void*);
                    printPointer(argument);
                }
                break;
            default:
                printer_putchar('%');
                printer_putchar(*it);
                break;
            }
        } else {
            printer_putchar(*it);
        }
        it++;
    }
    va_end(args);
}