#include "alloc.h"
#include "allocArea.h"
#include "ata.h"
#include "assert.h"
#include "cpu_context.h"
#include "klibc.h"
#include "kthread.h"
#include "list.h"
#include "mem.h"
#include "paging.h"
#include "serial.h"
#include "stack.h"
#include "synchro.h"
#include "time.h"

void testMemcpyPerf()
{
    struct test_struct {
        char data[4096];
    };
    // instantiate 2 structs. for our purposes, we don't care what data is in
    // there. set them to `volatile` so the compiler won't optimize away what we
    // do with them
    volatile struct test_struct dest, source;

    printf("Test Memcpy perf\n");
    // run through powers-of-two memcpy's, printing stats for each test
    for (size_t len = 1; len <= sizeof(dest); len <<= 1) {
        uint32_t start = read_cycle_counter(); // << Start count
        memcpy((void *)&dest, (void *)&source, len);
        uint32_t stop = read_cycle_counter(); // << Stop count

        // print out the cycles consumed
        printf("len = %d, %d %d cyccnt = %d, cycles/byte = %d\n", (uint32_t)len, stop, start,
               stop - start, (stop - start) / len);
    }
}

void testPhymem(void)
{
    printf("Testing memory PHY\n");
    struct phyMemDesc *allocated_page_list;
    struct phyMemDesc
        *page; // Cast in mem_desc to use it. In fact it's the addr of 4K free memory
    list_init(allocated_page_list);
    int allocCount = 0;
    int freeCount  = 0;

    uint freePageStatBegin, usedPageStatBegin;
    uint freePageStatAlloc, usedPageStatAlloc;
    uint freePageStatFree, usedPageStatFree;

    memGetStat(&freePageStatBegin, &usedPageStatBegin);

    while ((page = (struct phyMemDesc *)allocPhyPage(1)) != NULL) {
        page->phy_addr = allocCount;
        allocCount++;
        list_add_tail(allocated_page_list, page);
    }
    printf("%d pages allocated\n", allocCount);
    memGetStat(&freePageStatAlloc, &usedPageStatAlloc);
    assert(freePageStatAlloc == 0);
    assert((usedPageStatAlloc - usedPageStatBegin) == (uint)allocCount);

    while ((page = list_pop_head(allocated_page_list)) != NULL) {
        assertmsg(page->phy_addr == (ulong)freeCount, "page %d modified", page);
        assertmsg(unrefPhyPage((ulong)page) >= 0, "Failed to free page %d\n", (ulong)page);
        freeCount++;
    }
    printf("%d pages freed\n", freeCount);
    memGetStat(&freePageStatFree, &usedPageStatFree);
    assert(freePageStatFree == freePageStatBegin);
    assert(usedPageStatFree == usedPageStatBegin);

    assertmsg((page = (struct phyMemDesc *)allocPhyPage(1)) != NULL,
              "Cannot allocate memory\n");
    unrefPhyPage((ulong)page);
}

static void *testAllocNSet(size_t size)
{
    void *allocated = malloc(size);
    assert(allocated);
    memset(allocated, size, size);
    return allocated;
}

void testAllocArea(){
    vaddr_t area = areaAlloc(1, 0);
    vaddr_t area2 = areaAlloc(1, AREA_PHY_MAP);
    assert(area != area2);
    areaFree(area);
    areaFree(area2);
}

void testAlloc(void)
{
    assert(malloc(1410065407) == NULL);
    for (uint i = 0; i < PAGE_SIZE / (sizeof(struct slabEntry)); i++) {
        assert(malloc(sizeof(struct slabEntry)) != NULL);
    }
    for (uint i = 0; i < PAGE_SIZE / (sizeof(struct slabDesc)); i++) {
        assert(malloc(sizeof(struct slabDesc)) != NULL);
    }
    assert(malloc(1));
    assert(malloc(2));
    assert(malloc(3));
    assert(malloc(4));
    void *malloc1 = malloc(sizeof(void *));
    void *malloc2 = malloc(sizeof(void *));
    assert((char *)malloc2 == ((char *)malloc1 + sizeof(void *)));
    free(malloc2);
    void *malloc3 = malloc(sizeof(void *));
    assertmsg((char *)malloc2 == (char *)malloc3, " %d %d\n", malloc2, malloc3);
    free(malloc1);
    free(malloc3);
    void *alloc1 = testAllocNSet(1024);
    void *alloc2 = testAllocNSet(1024);
    void *alloc3 = testAllocNSet(1024);
    void *alloc4 = testAllocNSet(1024);
    void *alloc5 = testAllocNSet(1024);
    void *alloc6 = testAllocNSet(1024);
    void *alloc7 = testAllocNSet(4096);
    void *alloc8 = testAllocNSet(8192);
    free(alloc1);
    free(alloc2);
    free(alloc3);
    free(alloc4);
    free(alloc5);
    free(alloc6);
    free(alloc7);
    free(alloc8);
    void *alloc11 = testAllocNSet(1024);
    void *alloc12 = testAllocNSet(1024);
    void *alloc13 = testAllocNSet(1024);
    void *alloc14 = testAllocNSet(1024);
    void *alloc15 = testAllocNSet(1024);
    void *alloc16 = testAllocNSet(1024);
    free(alloc11);
    free(alloc12);
    free(alloc13);
    free(alloc14);
    free(alloc15);
    free(alloc16);
}

static void testPaging(void)
{
    printf("Testing paging\n");
    struct phyMemDesc *allocated_page_list;
    struct phyMemDesc
        *page; // Cast in mem_desc to use it. In fact it's the addr of 4K free memory
    list_init(allocated_page_list);
    int allocCount = 0;
    int freeCount  = 0;

    while ((page = (struct phyMemDesc *)areaAlloc(1, AREA_PHY_MAP)) != NULL) {
        memset(page, allocCount, PAGE_SIZE);
        allocCount++;
        list_add_tail(allocated_page_list, page);
    }
    printf("%d pages allocated\n", allocCount);

    while (!list_is_empty(allocated_page_list) &&
           (page = list_pop_head(allocated_page_list)) != NULL) {
        assertmsg((char)page->phy_addr == (char)freeCount, "page modified %d but is %d\n",
                  freeCount, page->phy_addr);
        areaFree((vaddr_t)page);
        freeCount++;
    }
    printf("%d pages freed\n", freeCount);

    assert(freeCount == allocCount);
    assertmsg((page = (struct phyMemDesc *)allocPhyPage(1)) != NULL,
              "Cannot allocate memory\n");
    unrefPhyPage((ulong)page);
}

static void test_backtrace_2(int a, int b)
{
    printStackTrace(a + b);
}

static void test_backtrace_1(int a)
{
    test_backtrace_2(a, 3);
}

void test_backtrace()
{
    test_backtrace_1(2);
}

/* ======================================================================
 * Demonstrate the use of the CPU kernet context management API:
 *  - A coroutine prints "Hlowrd" and switches to the other after each
 *    letter
 *  - A coroutine prints "el ol\n" and switches back to the other after
 *    each letter.
 * The first to reach the '\n' returns back to main.
 */
struct cpu_state *ctxt_hello1;
struct cpu_state *ctxt_hello2;
struct cpu_state *ctxt_main;
vaddr_t hello1_stack, hello2_stack;

static void reclaim_stack(void *stack_vaddr)
{
    free(stack_vaddr);
}

static void exit_hello12(void *stack_vaddr)
{
    cpu_context_exit_to(ctxt_main, (cpu_kstate_function_arg1_t *)reclaim_stack,
                        (vaddr_t)stack_vaddr);
}

static void hello1(void *strIn)
{
    char *str = (char *)strIn;
    for (; *str != '\n'; str++) {
        printf("hello1: %c\n", *str);
        cpu_context_switch(&ctxt_hello1, ctxt_hello2);
    }

    /* You can uncomment this in case you explicitly want to exit
       now. But returning from the function will do the same */
    /* cpu_context_exit_to(ctxt_main,
                   (cpu_kstate_function_arg1_t*) reclaim_stack,
                   hello1_stack); */
}

static void hello2(void *strIn)
{
    char *str = (char *)strIn;
    for (; *str != '\n'; str++) {
        printf("hello2: %c\n", *str);
        cpu_context_switch(&ctxt_hello2, ctxt_hello1);
    }

    /* You can uncomment this in case you explicitly want to exit
       now. But returning from the function will do the same */
    /* cpu_context_exit_to(ctxt_main,
                   (cpu_kstate_function_arg1_t*) reclaim_stack,
                   hello2_stack); */
}

void testCoroutine()
{
#define DEMO_STACK_SIZE 1024
    /* Allocate the stacks */
    hello1_stack = (vaddr_t)malloc(DEMO_STACK_SIZE);
    hello2_stack = (vaddr_t)malloc(DEMO_STACK_SIZE);

    /* Initialize the coroutines' contexts */
    cpu_kstate_init(&ctxt_hello1, (cpu_kstate_function_arg1_t *)hello1, (uint32_t) "Hlowrd",
                    (vaddr_t)hello1_stack, DEMO_STACK_SIZE,
                    (cpu_kstate_function_arg1_t *)exit_hello12, (uint32_t)hello1_stack);
    cpu_kstate_init(&ctxt_hello2, (cpu_kstate_function_arg1_t *)hello2, (uint32_t) "el ol\n",
                    (vaddr_t)hello2_stack, DEMO_STACK_SIZE,
                    (cpu_kstate_function_arg1_t *)exit_hello12, (uint32_t)hello2_stack);

    /* Go to first coroutine */
    printf("Printing Hello World\\n...\n");
    cpu_context_switch(&ctxt_main, ctxt_hello1);

    /* The first coroutine to reach the '\n' switched back to us */
    printf("Back in main !\n");
}

static void kthread1(void *strIn)
{
    char *str = (char *)strIn;
    for (; *str != '\n'; str++) {
        printf("kth1: %c\n", *str);
        kthreadYield();
    }
}

static void kthread2(void *strIn)
{
    char *str = (char *)strIn;
    for (; *str != '\n'; str++) {
        printf("kth2: %c\n", *str);
        kthreadYield();
    }
}

static int initialJiffies = 0;
void sleepThread(void *arg)
{
    (void)arg;
    int secSleep   = 0;
    initialJiffies = jiffies;
    while (secSleep < 5) {
        // printf("Sleeping loop %d\n", secSleep);
        secSleep++;
        kthreadMsleep(1000);
    }
    unsigned long ellapsedTime = jiffies_to_msecs(jiffies - initialJiffies);
    assertmsg(ellapsedTime >= 5000 && ellapsedTime < 5100, "ellapsedTime %d\n", ellapsedTime);
    kthreadMsleep(0);
    printf("I should never be showed\n");
    assert(1);
}

struct mutex mutexTest;

void mutThread(void *arg)
{
    (void)arg;
    printf("%s started\n", (char *)arg);
    int test = 5;
    while (test > 0) {
        mutexLock(&mutexTest);
        printf("%s sleep\n", (char *)arg);
        kthreadMsleep(1000);
        printf("%s up\n", (char *)arg);
        mutexUnlock(&mutexTest);
        test--;
    }
}
static int haveTimeout = 0;
void wqThread(void *arg)
{
    (void)arg;
    DECLARE_WAITQUEUE(test);
    waitQueueInit(&test);
    assert(waitTimeout(&test, 1000) == 1);
    waitQueueFree(&test);
    haveTimeout = 1;
}

void testKthread()
{
    mutexInit(&mutexTest);
    // It is not expected to have necessarily "Hello world\n" properly written
    kthreadCreate("Test2", (cpu_kstate_function_arg1_t *)kthread2, (void *)"el ol\n");
    kthreadCreate("Test1", (cpu_kstate_function_arg1_t *)kthread1, (void *)"Hlowrd\n");
    kthreadMsleep(1000);
    kthreadCreate("wq timeout", wqThread, NULL);
    kthreadMsleep(2000);
    assert(haveTimeout);
    kthreadCreate("sleep", sleepThread, NULL);
    kthreadMsleep(5000);
    kthreadCreate("mtest1", mutThread, "mut1");
    kthreadCreate("mtest2", mutThread, "mut2");
    kthreadCreate("mtest3", mutThread, "mut3");
}

void testATAThread(){
    uint16_t buf[DISK_SECTOR_SIZE/2];
    struct ata_device *dev = ATAGetDevice(0, 0);
    if(dev != NULL){
        ATAReadSector(dev, 0, 1, buf);
        printf("Reading from disk 0x%x 0x%x 0x%x 0x%x\n", buf[0], buf[1], buf[2], buf[3]);
        memset(buf, 0, sizeof(buf));
        buf[0]= 0x1;
        buf[1]= 0x2;
        buf[2]= 0x3;
        buf[3]= 0x4;
        ATAWriteSector(dev, 0, 1, buf);
    }
}

void testATA(){
    kthreadCreate("ATA_TEST", testATAThread, NULL);
    //testATAThread();
}

void run_test(void)
{
    testATA();
    testMemcpyPerf();
    {
        int test             = 1000;
        long long int test64 = 0x100000000;
        assert(printf("hello") == 5);
        assert(printf("hello\n") == 6);
        assert(printf("hello %d\n", test) == 11);
        assert(printf("hello %llx\n", test64) == 16);
        assert(printf("hello %c\n", 'a') == 8);
        assert(printf("hello %s\n", "world") == 12);
    }
    {
        char *strAlloc;
        int ret = asprintf(&strAlloc, "hello %s\n", "world");
        printf("asprint ret %d %s\n", ret, strAlloc);
        assert(ret == 13); // include the '\0'
        free(strAlloc);
    }
    testPaging();
    printf("Testing Serial\n");
    serialPutc('h');
    serialPutc('e');
    serialPutc('l');
    serialPutc('l');
    serialPutc('o');
    testAlloc();
    testAllocArea();
    printf("Testing backtrace\n");
    test_backtrace();
    testCoroutine();
    testKthread();
}