const std = @import("std");
pub const c = @import("c.zig").c;

pub const AsyncIO = opaque {
    pub inline fn getAsyncIOSize(asyncio: *AsyncIO) i64 {
        return c.SDL_GetAsyncIOSize(asyncio);
    }

    pub inline fn readAsyncIO(asyncio: *AsyncIO, ptr: ?*anyopaque, offset: u64, size: u64, queue: ?*AsyncIOQueue, userdata: ?*anyopaque) bool {
        return c.SDL_ReadAsyncIO(asyncio, ptr, offset, size, queue, userdata);
    }

    pub inline fn writeAsyncIO(asyncio: *AsyncIO, ptr: ?*anyopaque, offset: u64, size: u64, queue: ?*AsyncIOQueue, userdata: ?*anyopaque) bool {
        return c.SDL_WriteAsyncIO(asyncio, ptr, offset, size, queue, userdata);
    }

    pub inline fn closeAsyncIO(asyncio: *AsyncIO, flush: bool, queue: ?*AsyncIOQueue, userdata: ?*anyopaque) bool {
        return c.SDL_CloseAsyncIO(asyncio, flush, queue, userdata);
    }
};

pub const AsyncIOOutcome = extern struct {
    asyncio: ?*AsyncIO, // what generated this task. This pointer will be invalid if it was closed!
    type: AsyncIOTaskType, // What sort of task was this? Read, write, etc?
    result: AsyncIOResult, // the result of the work (success, failure, cancellation).
    buffer: ?*anyopaque, // buffer where data was read/written.
    offset: u64, // offset in the SDL_AsyncIO where data was read/written.
    bytes_requested: u64, // number of bytes the task was to read/write.
    bytes_transferred: u64, // actual number of bytes that were read/written.
    userdata: ?*anyopaque, // pointer provided by the app when starting the task
};

pub const AsyncIOQueue = opaque {
    pub inline fn destroyAsyncIOQueue(asyncioqueue: *AsyncIOQueue) void {
        return c.SDL_DestroyAsyncIOQueue(asyncioqueue);
    }

    pub inline fn getAsyncIOResult(asyncioqueue: *AsyncIOQueue, outcome: ?*AsyncIOOutcome) bool {
        return c.SDL_GetAsyncIOResult(asyncioqueue, outcome);
    }

    pub inline fn waitAsyncIOResult(asyncioqueue: *AsyncIOQueue, outcome: ?*AsyncIOOutcome, timeoutMS: i32) bool {
        return c.SDL_WaitAsyncIOResult(asyncioqueue, outcome, timeoutMS);
    }

    pub inline fn signalAsyncIOQueue(asyncioqueue: *AsyncIOQueue) void {
        return c.SDL_SignalAsyncIOQueue(asyncioqueue);
    }
};

pub inline fn asyncIOFromFile(file: [*c]const u8, mode: [*c]const u8) ?*AsyncIO {
    return c.SDL_AsyncIOFromFile(file, mode);
}

pub inline fn createAsyncIOQueue() ?*AsyncIOQueue {
    return c.SDL_CreateAsyncIOQueue();
}

pub inline fn loadFileAsync(file: [*c]const u8, queue: ?*AsyncIOQueue, userdata: ?*anyopaque) bool {
    return c.SDL_LoadFileAsync(file, queue, userdata);
}