const c = @import("c");
const zpy = @import("root.zig");

pub const Tuple = extern struct {
    const Self = @This();

    data: c.PyObject,

    pub fn new(length: usize) !*Self {
        return @ptrCast(c.PyTuple_New(@intCast(length)) orelse return error.Exception);
    }

    pub fn pack(values: []const *zpy.Object) !*Self {
        var tuple = try new(values.len);
        errdefer tuple.asObject().decref();

        for (values, 0..) |value, index| {
            try tuple.set(index, value);
        }

        return tuple;
    }

    pub fn size(self: *const Self) usize {
        return c.PyTuple_GET_SIZE(@ptrCast(self));
    }

    pub fn get(self: *const Self, index: usize) !*zpy.Object {
        return @ptrCast(
            c.PyTuple_GetItem(
                @ptrCast(self),
                @intCast(index),
            ) orelse return error.Exception,
        );
    }

    pub fn getUnchecked(self: *Self, index: usize) *zpy.Object {
        return @ptrCast(c.PyTuple.GET_ITEM(
            @ptrCast(self),
            @intCast(index),
        ));
    }

    pub fn set(self: *Self, index: usize, value: *zpy.Object) !void {
        if (c.PyTuple_SetItem(@ptrCast(self), @intCast(index), @ptrCast(value)) == -1) {
            return error.Exception;
        }
    }

    pub fn resize(self: *Self, newlen: usize) !void {
        if (c._PyTuple_Resize(@ptrCast(&self), @intCast(newlen)) == -1) {
            return error.Exception;
        }
    }

    pub fn asObject(self: *Self) *zpy.Object {
        return @ptrCast(self);
    }
};