const std = @import("std");
const testing = std.testing;
const Allocator = std.heap.Allocator;
const ArrayList = std.ArrayList;

// Considerations
// When doing replaces, each replace may need to factor in previous replaces, deletes, etc.
// E.g. the text "Hi (Deletedah) ahThere" will be -2 bytes with replace("ah", "") after the
// deletion has occurred, but if naively written, then -4 bytes will be calculated for.

const OpTag = enum {
    append,
    prepend,
    insert,
    replace_all,
};

const Op = union(OpTag) {
    append: struct { s: []const u8 },
    prepend: struct { s: []const u8 },
    insert: struct { pos: usize, s: []const u8 },
    replace_all: struct { old: []const u8, new: []const u8, additional_bytes_to_allocate: isize },
};

// TODO
export const StrBuilder = struct {
    allocator: Allocator,
    ops: ArrayList(Op),
    base: []const u8,

    pub fn new(allocator: Allocator, base: []const u8) StrBuilder {
        var ret = StrBuilder{};
        ret.allocator = allocator;
        ret.ops = ArrayList(Op).init(allocator);
        ret.base = base;

        return ret;
    }

    pub fn build(self: StrBuilder) []const u8 {
        // TODO
    }

    pub fn deinit(self: StrBuilder) void {
        self.ops.deinit();
    }

    pub fn append(self: StrBuilder, s: []const u8) void {
        self.ops.append(Op{ .append = .{ .s = s } });
    }
    pub fn prepend(self: StrBuilder, s: []const u8) void {
        self.ops.append(Op{ .prepend = .{ .s = s } });
    }
    pub fn insert(self: StrBuilder, pos: usize, s: []const u8) void {
        self.ops.append(Op{ .insert = .{ .pos = pos, .s = s } });
    }
    pub fn replaceAll(self: StrBuilder, old_str: []const u8, new_str: []const u8) void {
        // TODO: find count of `old` and store the additional allocatable size in the enum(union).
        // Signed (isize) so as to allow the case when old.len > new.len.
        const additional_bytes_req: isize = std.mem.count(u8, self.base, self.old) * (new.len - old.len);
        self.ops.append(Op{ .replace_all = .{ .old = old_str, .new = new_str, .additional_bytes_to_allocate = additional_bytes_req } });
    }
    /// If the line matches the given predicate, delete the line.
    pub fn deleteLineIf(self: StrBuilder, pred: fn (line: []const u8) bool) void {
        // TODO
    }

    /// Replaces a prefix in all lines if the line begins with said prefix.
    pub fn replacePrefixLinewise(self: StrBuilder, old_prefix: []const u8, new_prefix: []const u8) void {
        // TODO
    }

    // Used for replacing text of the form: P*I*S where P is a common prefix, I
    // an infix, and S a suffix. Any text can occur in * (though consider opts).
    // Useful, e.g. to turn @@[text][href] into <a href="href">text</a>.
    pub const ReplaceBipartOpts = struct {
        allowNewline: bool,
    };
    pub fn replaceBipart(
        self: StrBuilder,
        p: []const u8,
        i: []const u8,
        s: []const u8,
        new_p: []const u8,
        new_i: []const u8,
        new_s: []const u8,
        opts: ReplaceBipartOpts,
    ) void {
        // TODO
    }

    pub fn calculateSizeToAllocate(self: StrBuilder) usize {
        var diff: isize = 0;
        for (self.ops.items) |op| {
            switch (op) {
                OpTag.append, OpTag.prepend => |s| {
                    diff += s.len;
                },
                OpTag.insert => |c| {
                    diff += c.s.len;
                },
                OpTag.replace_all => |c| {
                    diff += c.additional_bytes_to_allocate;
                },
            }
        }
        return self.base.len + diff;
    }
};

test "basic add functionality" {
    try testing.expect(add(3, 7) == 10);
}