const std = @import("std");
const Allocator = std.mem.Allocator;

pub const TableColumnAlign = enum { left, right, center };

pub const TableRow = struct {
    cells: [][]u8,
};

pub const TablePayload = struct {
    rows: []TableRow,
    alignments: []TableColumnAlign,
    column_count: usize,

    pub fn deinit(self: *TablePayload, alloc: Allocator) void {
        deinitTableRows(alloc, self.rows);
        alloc.free(self.rows);
        alloc.free(self.alignments);
        self.* = undefined;
    }

    pub fn clone(self: TablePayload, alloc: Allocator) !TablePayload {
        const rows = try alloc.alloc(TableRow, self.rows.len);
        var copied_rows: usize = 0;
        errdefer {
            deinitTableRows(alloc, rows[0..copied_rows]);
            alloc.free(rows);
        }

        for (self.rows, 0..) |row, row_index| {
            const cells = try alloc.alloc([]u8, row.cells.len);
            var copied_cells: usize = 0;
            errdefer {
                for (cells[0..copied_cells]) |cell| alloc.free(cell);
                alloc.free(cells);
            }
            for (row.cells, 0..) |cell, cell_index| {
                cells[cell_index] = try alloc.dupe(u8, cell);
                copied_cells += 1;
            }
            rows[row_index] = .{ .cells = cells };
            copied_rows += 1;
        }

        const alignments = try alloc.dupe(TableColumnAlign, self.alignments);
        errdefer alloc.free(alignments);
        return .{
            .rows = rows,
            .alignments = alignments,
            .column_count = self.column_count,
        };
    }
};

pub const CodeBlockPayload = struct {
    language: []u8,
    code: []u8,

    pub fn deinit(self: *CodeBlockPayload, alloc: Allocator) void {
        alloc.free(self.language);
        alloc.free(self.code);
        self.* = undefined;
    }

    pub fn clone(self: CodeBlockPayload, alloc: Allocator) !CodeBlockPayload {
        const language = try alloc.dupe(u8, self.language);
        errdefer alloc.free(language);
        return .{
            .language = language,
            .code = try alloc.dupe(u8, self.code),
        };
    }
};

pub const TableCompletion = struct {
    ctx: *anyopaque,
    /// Takes ownership of `table` only when it returns successfully.
    deliver: *const fn (ctx: *anyopaque, table: TablePayload, out: *std.ArrayList(u8)) anyerror!void,
};

pub const CodeBlockCompletion = struct {
    ctx: *anyopaque,
    /// Takes ownership of `block` only when it returns successfully.
    deliver: *const fn (ctx: *anyopaque, block: CodeBlockPayload, out: *std.ArrayList(u8)) anyerror!void,
};

pub const ThematicRuleCompletion = struct {
    ctx: *anyopaque,
    deliver: *const fn (ctx: *anyopaque, out: *std.ArrayList(u8)) anyerror!void,
};

pub const MarkdownCompletions = struct {
    table: ?*const TableCompletion = null,
    code: ?*const CodeBlockCompletion = null,
    thematic_rule: ?*const ThematicRuleCompletion = null,
};

pub fn deinitTableRows(alloc: Allocator, rows: []TableRow) void {
    for (rows) |row| {
        for (row.cells) |cell| alloc.free(cell);
        alloc.free(row.cells);
    }
}

pub const FootnoteSink = struct {
    ctx: *anyopaque,
    register: *const fn (ctx: *anyopaque, alloc: Allocator, label: []const u8) anyerror!usize,
};