package main

import "core:fmt"
import "core:runtime"
import "core:os"
import "core:mem"
import "core:strings"
import "core:strconv"

// Letting a user edit an object via the console!

SampleObject :: struct {
    name: string,
    job_title: string,
    birth_year: int,
    birth_month: int,
}

main :: proc() {
    person: SampleObject;
    person.name = "hasen";
    fmt.printf("address of our object: %d\n", cast(rawptr)(&person));
    edit_object(&person);
    fmt.println("object now is:", person);
}

edit_object :: proc(obj: any) {
    fmt.println("Editing object:", obj);
    // expect a pointer to a struct, or the struct info to be in there somewhere!
    ptr : rawptr = obj.data;
    info := type_info_of(obj.id);
    struct_info: runtime.Type_Info_Struct;

    findloop: for {
        // fmt.println("type_info:", info.variant);
        switch v in info.variant {
            case runtime.Type_Info_Pointer:
                info = v.elem;
                ptr = (cast(^rawptr)ptr)^; // ptr was a pointer to a pointer; go inside!
            case runtime.Type_Info_Named:
                info = v.base;
            case runtime.Type_Info_Struct:
                struct_info = v;
                break findloop;
            case:
                fmt.println("unknown variant!", v);
                return;
        }
    }
    fmt.printf("edit_object :: pointer is: %d\n", ptr);

    input := make([]byte, 20);
    for name, index in struct_info.names {
        type := struct_info.types[index];
        offset := struct_info.offsets[index];
        fieldPtr := rawptr(uintptr(ptr) + offset);
        fieldValue := any{fieldPtr, type.id};
        fmt.printf("%s> ", name);
        count, err := os.read(context.stdin, input);
        if err == 0 && count > 1 {
            userInput := string(input[:count-1]);
            dynamically_assign(fieldValue, userInput);
        }
        fmt.println("object now is:", obj);
    }
}

dynamically_assign :: proc(obj: any, userInput: string) {
    ptr := obj.data;
    switch it in obj {
        case int: (cast(^int)ptr)^ = strconv.parse_int(userInput);
        case uint: (cast(^uint)ptr)^ = strconv.parse_uint(userInput);
        case i64: (cast(^i64)ptr)^ = strconv.parse_i64(userInput);
        case u64: (cast(^u64)ptr)^ = strconv.parse_u64(userInput);
        case string: (cast(^string)ptr)^ = strings.clone(userInput);
        case: fmt.println("we don't know how to assigned to", obj);
    }
}