#include <stdio.h>

#include "pwyazh.h"

typedef struct Node {
    struct Node *next;
    struct Node *prev;
    F32 value;
} Node;

void
print_dll(Node *f)
{
    for (Node *c = f;
         c;
         c = c->next)
    {
        printf("%f%c", c->value, (c->next) ? ' ' : '\n');
    }
}

void
clear_dll(Node **f, Node **l)
{
    for (Node *c = (*f)->next;
         c;
         c = c->next)
    {
        MemoryZeroStruct(c->prev);
    }
    MemoryZeroStruct(*f);
    MemoryZeroStruct(*l);
    *f = *l = 0;
}

int
main(void)
{
    V3F pos = v3f(1.0f, 2.0f, 1.0f);
    pos = v3f_add(pos, v3f(-1.0f, 2.0f, 0.23f));
    pos = v3f_scalef(pos, 10.0f);
    printf("scaled: %f %f %f\n", pos.x, pos.y, pos.z);

    F32 length = v3f_length(pos);
    Assert(length > 0.0f);
    printf("length: %f\n", length);

    V3F positions[] = {
        { -1.0f, 0.0f, 0.0f },
        { 1.0f, 0.0f, 0.0f },
        { 0.0f, 1.0f, 0.0f },
        { 0.0f, 0.0f, -1.0f },
    };
    for (U32 pos_index = 0;
         pos_index < ArrayCount(positions);
         ++pos_index)
    {
        V3F *pos = positions+pos_index;
        printf("%d: %f %f %f\n", pos_index,
               pos->x, pos->y, pos->z);
        U64 ptr_as_int = IntFromPtr(pos);
        printf("ptr: %lx\n", ptr_as_int);
        void *ptr = PtrFromInt(ptr_as_int);
        V3F *as_pos = (V3F *)ptr;
        printf("decode: %f %f %f\n",
               as_pos->x, as_pos->y, as_pos->z);
    }

    printf("Offset of y: %lld\n", OffsetOfMember(V3F, y));

    S32 min = Min(10, 2);
    S32 max = Max(10, 2);
    printf("min: %d\n", min);
    printf("max: %d\n", max);

    S32 source[100];
    for (S32 index = 0;
         index < 100;
         ++index)
    {
        source[index] = index;
        printf("%d%c", source[index], (index < 99) ? ' ' : '\n');
    }

    S32 dest[100];
    MemoryCopyArray(dest, source);
    printf("dest: ");
    for (S32 index = 0;
         index < 100;
         ++index)
    {
        printf("%d%c", dest[index], (index < 99) ? ' ' : '\n');
    }
    printf("compare: %d\n", MemoryMatch(source, dest, sizeof(source)));

    MemoryZeroArray(dest);
    printf("dest: ");
    for (S32 index = 0;
         index < 100;
         ++index)
    {
        printf("%d%c", dest[index], (index < 99) ? ' ' : '\n');
    }
    printf("compare: %d\n", MemoryMatch(source, dest, sizeof(source)));

    V3F first = v3f_zero();
    V3F second;
    printf("struct compare: %d\n", MemoryMatch(&first, &second, sizeof(V3F)));
    MemoryCopyStruct(&second, &first);
    printf("struct compare: %d\n", MemoryMatch(&first, &second, sizeof(V3F)));

    MAT4 mat = mat4_identity();
    printf("det: %f\n", mat4_det(mat));

    {
        U32 node_count = 10;
        Arena *arena = arena_alloc(Megabytes(64));
        Node *nodes = arena_push_size(arena, node_count*sizeof(Node));
        MemoryZero(nodes, node_count*sizeof(Node));
        Node *f = 0;
        Node *l = 0;
        for (U32 node_index = 0;
             node_index < node_count;
             ++node_index)
        {
            nodes[node_index].value = node_index;
            DLLPushBack(f, l, &nodes[node_index]);
        }
        print_dll(f);

        for (Node *c = f;
             c;
             c = c->next)
        {
            if (c->value == 5.0f) {
                DLLRemove(f, l, c);
            }
        }

        DLLPushBack(f, l, &nodes[5]);

        for (U32 node_index = 0;
             node_index < node_count;
             ++node_index)
        {
            Node *node = nodes+node_index;
            printf("%u: prev: %llx ptr: %llx next: %llx %f\n",
                   node_index, IntFromPtr(node->prev),
                   IntFromPtr(node), IntFromPtr(node->next), node->value);
        }

        clear_dll(&f, &l);
        for (U32 node_index = 0;
             node_index < node_count;
             ++node_index)
        {
            Node *node = nodes+node_index;
            printf("%u: prev: %llx ptr: %llx next: %llx %f\n",
                   node_index, IntFromPtr(node->prev),
                   IntFromPtr(node), IntFromPtr(node->next), node->value);
        }
        print_dll(f);
        arena_release(arena);
    }

    U64 temp_size = Kilobytes(1);
    Arena *temp = arena_alloc(temp_size);
    S32 test_count = temp_size/sizeof(S32);
    S32 *test = arena_push_size(temp, test_count*sizeof(S32));
    MemoryZero(test, test_count*sizeof(S32));
    S32 i;
    for (i = 0;
         i < test_count;
         ++i)
    {
        S32 *item = test+i;
        *item = i;
        printf("%d%c", *item, (i == test_count-1) ? '\n' : ' ');
    }
    arena_release(temp);

    temp = arena_alloc(temp_size);
    String8 str = str8_cstring((U8 *)"This is a c string");
    printf("%s", str.str);
    arena_release(temp);
    return(0);
}