import "std/fs.zc"
import "std/json.zc"
import "std/map.zc"
import "std/option.zc"
import "std/string.zc"
import "std/core.zc"

raw {
    typedef struct JsonValue* JsonValuePtr;
}

struct Config {
    server_name: String;
    port: int;
    logging: bool;
}

fn main() {
    let path = "examples/data/config.json";
    
    let content_res = File::read_all(path);
    if content_res.is_err() {
        !"Failed to read config file: {content_res.err}";
        return 1;
    }
    
    let json_str = content_res.unwrap();

    let json_res = JsonValue::parse(json_str.c_str());
    if json_res.is_err() {
        !"JSON Parse Error: {json_res.err}";
        json_str.free();
        return 1;
    }
    
    let root = json_res.unwrap();
    
    defer {
        json_str.free();
        JsonValue::free(root);
        free(root);
    }
    
    if (*root).kind.tag != JsonType::JSON_OBJECT().tag {
         !"Expected JSON Object at root";
         return 1;
    }
    
    let config = Config { 
        server_name: String::new("Unknown"), 
        port: 0, 
        logging: false 
    };

    let obj_map = (*root).object_val;

    if Map<JsonValue*>::contains(obj_map, "server_name") {
        let opt = Map<JsonValue*>::get(obj_map, "server_name");
        let val = opt.unwrap();
        if (*val).kind.tag == JsonType::JSON_STRING().tag {
            config.server_name.free();
            config.server_name = String::new((*val).string_val);
        }
    }
    
    if Map<JsonValue*>::contains(obj_map, "port") {
        let opt = Map<JsonValue*>::get(obj_map, "port");
        let val = opt.unwrap();
        if (*val).kind.tag == JsonType::JSON_NUMBER().tag {
            config.port = (int)(*val).number_val;
        }
    }
    
    if Map<JsonValue*>::contains(obj_map, "features") {
        let opt = Map<JsonValue*>::get(obj_map, "features");
        let features = opt.unwrap();
        if (*features).kind.tag == JsonType::JSON_OBJECT().tag {
            let f_obj = (*features).object_val;
            if Map<JsonValue*>::contains(f_obj, "logging") {
                let l_opt = Map<JsonValue*>::get(f_obj, "logging");
                let l = l_opt.unwrap();
                if (*l).kind.tag == JsonType::JSON_BOOL().tag {
                    config.logging = (*l).bool_val;
                }
            }
        }
    }
    
    "Configuration Loaded:";
    let s_name = config.server_name.c_str();
    "Server:  {s_name}";
    "Port:    {config.port}";
    "Logging: {config.logging}";
    
    config.server_name.free();
    
    return 0;
}