const std = @import("std");

const c = @cImport({
    @cDefine("DEBUG", "1");
    @cInclude("stdio.h");
    @cInclude("string.h");
    @cInclude("cmph.h");
});

const tempMph = "temp.mph";

pub fn main() !void {}

test "simple cmph usage" {
    var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    const arena = arena_instance.allocator();
    const stdout = std.io.getStdOut().writer();
    const stderr = std.io.getStdErr().writer();

    _ = stdout;
    var vector = std.ArrayList([*:0]const u8).init(arena);
    try vector.appendSlice(&.{
        "aaaaaaaaaa",
        "bbbbbbbbbb",
        "cccccccccc",
        "dddddddddd",
        "eeeeeeeeee",
        "ffffffffff",
        "gggggggggg",
        "hhhhhhhhhh",
        "iiiiiiiiii",
        "jjjjjjjjjj",
    });
    var vector2 = try vector.clone();
    var nkeys = @truncate(c_uint, vector.items.len);

    var mphf_fd = c.fopen(tempMph, "w");
    var cvector = @ptrCast([*c][*c]u8, vector.toOwnedSlice().ptr);
    var source = c.cmph_io_vector_adapter(cvector, nkeys);
    defer c.cmph_io_vector_adapter_destroy(source);
    var config: *c.cmph_config_t = c.cmph_config_new(source) orelse return error.OutOfMemory;
    c.cmph_config_set_algo(config, c.CMPH_BRZ);
    c.cmph_config_set_mphf_fd(config, mphf_fd);
    var hash: *c.cmph_t = c.cmph_new(config) orelse return error.OutOfMemory;
    c.cmph_config_destroy(config);
    _ = c.cmph_dump(hash, mphf_fd);
    c.cmph_destroy(hash);
    try closeCFile(mphf_fd);

    mphf_fd = c.fopen(tempMph, "r");
    defer _ = c.fclose(mphf_fd);

    var got_hash: ?*c.cmph_t = c.cmph_load(mphf_fd);
    if (got_hash) |real_hash| {
        hash = real_hash;
    } else {
        try stderr.print("failed to unwrap hash\n", .{});
    }
    defer c.cmph_destroy(hash);

    try stderr.print("\n", .{});
    for (vector2.items) |key| {
        var id = c.cmph_search(hash, key, @truncate(c_uint, c.strlen(key)));
        try stderr.print("key: {s}, id: {d}\n", .{ key, id });
    }
}

fn closeCFile(f: *c.FILE) !void {
    var close_code = c.fclose(f);
    if (close_code != 0) {
        return std.os.unexpectedErrno(std.os.errno(close_code));
    }
}

const expectEqual = std.testing.expectEqual;

test "char**" {
    var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    const arena = arena_instance.allocator();

    var arrl = std.ArrayList([*:0]const u8).init(arena);
    try arrl.append("foo");
    try arrl.append("bar");

    var arr: [*][*:0]const u8 = arrl.toOwnedSlice().ptr;

    try expectEqual(@TypeOf(arr[0]), [*:0]const u8);
    try expectEqual(arr[0][2], 'o');
    try expectEqual(arr[0][3], 0);
}