void Map__remove(caStack* stack)
{
    caValue* out = circa_output(stack, 0);
    copy(circa_input(stack, 0), out);

    hashtable_remove(out, circa_input(stack, 1));
}

void List__insert(caStack* stack)
{
    caValue* out = circa_output(stack, 0);
    copy(circa_input(stack, 0), out);

    copy(circa_input(stack, 1), list_insert(out, circa_int_input(stack, 2)));
}

void Term__tweak(caStack* stack)
{
    Term* t = as_term_ref(circa_input(stack, 0));
    if (t == NULL)
        return circa_output_error(stack, "NULL reference");

    int steps = tweak_round(to_float(circa_input(stack, 1)));

    caValue* val = term_value(t);

    if (steps == 0)
        return;

    if (is_float(val)) {
        float step = get_step(t);

        // Do the math like this so that rounding errors are not accumulated
        float new_value = (tweak_round(as_float(val) / step) + steps) * step;
        set_float(val, new_value);

    } else if (is_int(val))
        set_int(val, as_int(val) + steps);
    else
        circa_output_error(stack, "Ref is not an int or number");
}

void Branch__link(caStack* stack)
{
    Branch* self = (Branch*) circa_branch(circa_input(stack, 0));
    Branch* source = (Branch*) circa_branch(circa_input(stack, 1));

    branch_link_missing_functions(self, source);
}

void make_client(Stack* stack)
{
    printf("make_client\n");
    Connection* connection = new Connection();

    ca_assert(stack->world->libuvWorld->uv_loop != NULL);
    uv_tcp_init(stack->world->libuvWorld->uv_loop, &connection->uv_tcp);
    connection->uv_tcp.data = connection;

    Value* ip = circa_input(stack, 0);
    Value* port = circa_input(stack, 1);

    sockaddr_in bind_addr = uv_ip4_addr(circa_string(ip), circa_int(port));
#if 0
    if (uv_ip4_addr(circa_string(ip), circa_int(port), &bind_addr)) {
        printf("error from uv_ip4_addr\n");
        return;
    }
#endif

    uv_connect_t* uv_connect = (uv_connect_t*) malloc(sizeof(*uv_connect));
    uv_connect->data = connection;
    if (uv_tcp_connect(uv_connect, &connection->uv_tcp, bind_addr, client_on_connect)) {
        printf("uv_tcp_connect error\n");
    }

    Value* out = circa_set_default_output(stack, 0);
    circa_set_native_ptr(circa_index(out, 0), connection, ConnectionRelease);
    printf("make_client fin\n");
}

void Connection__send(Stack* stack)
{
    Connection* connection = (Connection*) circa_native_ptr(circa_index(circa_input(stack, 0), 0));

    Value* asStr = circa_alloc_value();
    circa_to_string(circa_input(stack, 1), asStr);
    circa_uv_write((uv_stream_t*) &connection->uv_tcp, asStr, true);
}

void Branch__call(caStack* stack)
{
    Branch* branch = as_branch(circa_input(stack, 0));
    if (branch == NULL)
        return circa_output_error(stack, "NULL branch");

    caValue* inputs = circa_input(stack, 1);
    push_frame_with_inputs(stack, branch, inputs);
}

void Map__set(caStack* stack)
{
    caValue* out = circa_output(stack, 0);
    copy(circa_input(stack, 0), out);

    caValue* key = circa_input(stack, 1);
    caValue* value = circa_input(stack, 2);

    copy(value, hashtable_insert(out, key, false));
}

void Type__property(caStack* stack)
{
    Type* type = as_type(circa_input(stack, 0));
    const char* str = as_cstring(circa_input(stack, 1));
    caValue* prop = get_type_property(type, str);
    if (prop == NULL)
        set_null(circa_output(stack, 0));
    else
        copy(prop, circa_output(stack, 0));
}

void Dict__set(caStack* stack)
{
    caValue* dict = circa_output(stack, 0);
    copy(circa_input(stack, 0), dict);

    const char* key = circa_string_input(stack, 1);
    caValue* value = circa_input(stack, 2);

    copy(value, dict_insert(dict, key));
}

void List__set(caStack* stack)
{
    caValue* self = circa_output(stack, 0);
    copy(circa_input(stack, 0), self);

    int index = circa_int_input(stack, 1);
    caValue* value = circa_input(stack, 2);

    touch(self);
    copy(value, list_get(self, index));
}

void Map__get(caStack* stack)
{
    caValue* table = circa_input(stack, 0);
    caValue* key = circa_input(stack, 1);
    caValue* value = hashtable_get(table, key);
    if (value == NULL) {
        std::string msg = "Key not found: " + to_string(key);
        return circa_output_error(stack, msg.c_str());
    }
    copy(value, circa_output(stack, 0));
}

void Map__insertPairs(caStack* stack)
{
    caValue* out = circa_output(stack, 0);
    copy(circa_input(stack, 0), out);

    caValue* pairs = circa_input(stack, 1);
    for (int i=0; i < list_length(pairs); i++) {
        caValue* pair = list_get(pairs, i);
        copy(list_get(pair, 1), hashtable_insert(out, list_get(pair, 0), false));
    }
}

int main(int argc, char** argv)
{
    caWorld* world = circa_initialize();

    circa_load_module_from_file(world, "ClassA", "ClassA.ca");

    // circa_dump_b(circa_kernel(world));

    caStack* stack = circa_alloc_stack(world);

    circa_push_function_by_name(stack, "create_ClassA");
    circa_run(stack);

    if (circa_has_error(stack))
        circa_print_error_to_stdout(stack);

    caValue* classA = circa_alloc_value();
    circa_move(circa_output(stack, 0), classA);
    circa_pop(stack);

    // Dump to stdout
    circa_push_function_by_name(stack, "ClassA.dump");
    circa_copy(classA, circa_input(stack, 0));
    circa_run(stack);
    if (circa_has_error(stack))
        circa_print_error_to_stdout(stack);
    circa_pop(stack);

    for (int i=0; i < 5; i++) {
        // Increment
        circa_push_function_by_name(stack, "ClassA.increment");
        circa_copy(classA, circa_input(stack, 0));
        circa_run(stack);
        if (circa_has_error(stack))
            circa_print_error_to_stdout(stack);

        // Using index #1 not 0:
        circa_move(circa_output(stack, 1), classA);
        circa_pop(stack);

        // And dump
        circa_push_function_by_name(stack, "ClassA.dump");
        circa_copy(classA, circa_input(stack, 0));
        circa_run(stack);
        if (circa_has_error(stack))
            circa_print_error_to_stdout(stack);
        circa_pop(stack);
    }

    circa_dealloc_value(classA);
    circa_dealloc_stack(stack);
    circa_shutdown(world);
}

void make_server(Stack* stack)
{
    Value* ip = circa_input(stack, 0);
    Value* port = circa_input(stack, 1);
    Value* type = circa_input(stack, 2);

    Server* server = new Server();

    if (circa_string_equals(type, ":tcp")) {
        server->serverType = TCP;
    } else if (circa_string_equals(type, ":websock")) {
        server->serverType = WEBSOCK;
        memset(&server->parser_settings, 0, sizeof(server->parser_settings));
        server->parser_settings.on_message_begin = http_on_message_begin;
        server->parser_settings.on_url = http_on_url;
        server->parser_settings.on_status = http_on_status;
        server->parser_settings.on_header_field = http_on_header_field;
        server->parser_settings.on_header_value = http_on_header_value;
        server->parser_settings.on_headers_complete = http_on_headers_complete;
        server->parser_settings.on_body = http_on_body;
        server->parser_settings.on_message_complete = http_on_message_complete;

    } else {
        Value msg;
        circa_set_string(&msg, "Unrecognized server type: ");
        circa_string_append_val(&msg, type);
        circa_output_error_val(stack, &msg);
        delete server;
        return;
    }

    uv_loop_t* loop = get_uv_loop(stack->world);
    circa_set_list(&server->connections, 0);

    uv_tcp_init(stack->world->libuvWorld->uv_loop, &server->uv_tcp);

    struct sockaddr_in bind_addr = uv_ip4_addr(circa_string(ip), circa_int(port));

    uv_tcp_bind(&server->uv_tcp, bind_addr);
    int err = uv_listen((uv_stream_t*) &server->uv_tcp, 128, server_on_connect);
    server->uv_tcp.data = server;

    if (err) {
        Value msg;
        circa_set_string(&msg, "Listen error: ");
        circa_string_append(&msg, uv_err_name(uv_last_error(loop)));
        circa_output_error_val(stack, &msg);
        return;
    }

    Value* out = circa_set_default_output(stack, 0);
    circa_set_native_ptr(circa_index(out, 0), server, ServerRelease);
}

void List__extend(caStack* stack)
{
    caValue* out = circa_output(stack, 1);
    copy(circa_input(stack, 0), out);

    caValue* additions = circa_input(stack, 1);

    int oldLength = list_length(out);
    int additionsLength = list_length(additions);

    list_resize(out, oldLength + additionsLength);
    for (int i = 0; i < additionsLength; i++)
        copy(list_get(additions, i), list_get(out, oldLength + i));
}

void Term__assign(caStack* stack)
{
    Term* target = as_term_ref(circa_input(stack, 0));
    if (target == NULL) {
        circa_output_error(stack, "NULL reference");
        return;
    }

    caValue* source = circa_input(stack, 1);

    circa::copy(source, term_value(target));

    // Probably should update term->type at this point.
}

void List__join(caStack* stack)
{
    caValue* input = circa_input(stack, 0);
    caValue* joiner = circa_input(stack, 1);

    caValue* out = circa_output(stack, 0);
    set_string(out, "");

    for (int i=0; i < list_length(input); i++) {
        if (i != 0)
            string_append(out, joiner);

        string_append(out, list_get(input, i));
    }
}

void Dict__get(caStack* stack)
{
    caValue* dict = circa_input(stack, 0);
    const char* key = circa_string_input(stack, 1);

    copy(dict_get(dict, key), circa_output(stack, 0));
}

void Branch__version(caStack* stack)
{
    Branch* branch = as_branch(circa_input(stack, 0));
    if (branch == NULL)
        return circa_output_error(stack, "NULL branch");
    set_int(circa_output(stack, 0), branch->version);
}