const std = @import("std");

pub const Span = struct {
    raw_start: usize,
    raw_end: usize,

    pub fn isValid(self: Span, input_len: usize) bool {
        return self.raw_start < self.raw_end and self.raw_end <= input_len;
    }

    pub fn contains(self: Span, raw_offset: usize) bool {
        return self.raw_start < raw_offset and raw_offset < self.raw_end;
    }
};

pub const ImageTokenSpan = struct {
    span: Span,
    id: usize,
};

/// Projects a registered span through an insertion. Insertion at the start
/// moves the entity; insertion at the end leaves it in place. Null means the
/// edit entered the entity or arithmetic overflowed.
pub fn afterInsert(span: Span, raw_offset: usize, byte_len: usize) ?Span {
    if (byte_len == 0 or raw_offset >= span.raw_end) return span;
    if (raw_offset > span.raw_start) return null;
    return .{
        .raw_start = std.math.add(usize, span.raw_start, byte_len) catch return null,
        .raw_end = std.math.add(usize, span.raw_end, byte_len) catch return null,
    };
}

/// Projects a registered span through a deletion. Null means the deleted range
/// overlapped the entity.
pub fn afterDelete(span: Span, delete_start: usize, delete_end: usize) ?Span {
    if (delete_start >= delete_end or delete_start >= span.raw_end) return span;
    if (delete_end <= span.raw_start) {
        const removed = delete_end - delete_start;
        return .{
            .raw_start = span.raw_start - removed,
            .raw_end = span.raw_end - removed,
        };
    }
    return null;
}

pub fn overlaps(a: Span, b: Span) bool {
    return a.raw_start < b.raw_end and b.raw_start < a.raw_end;
}

pub fn containsSpan(outer: Span, inner: Span) bool {
    return outer.raw_start <= inner.raw_start and inner.raw_end <= outer.raw_end;
}

test "entity spans shift only for edits outside their contents" {
    const span = Span{ .raw_start = 4, .raw_end = 10 };

    try std.testing.expectEqual(Span{ .raw_start = 6, .raw_end = 12 }, afterInsert(span, 4, 2).?);
    try std.testing.expectEqual(span, afterInsert(span, 10, 2).?);
    try std.testing.expect(afterInsert(span, 7, 2) == null);

    try std.testing.expectEqual(Span{ .raw_start = 2, .raw_end = 8 }, afterDelete(span, 1, 3).?);
    try std.testing.expectEqual(span, afterDelete(span, 10, 12).?);
    try std.testing.expect(afterDelete(span, 3, 5) == null);
    try std.testing.expect(afterDelete(span, 5, 7) == null);
}

test "entity span relationship helpers use half-open ranges" {
    const entity = Span{ .raw_start = 4, .raw_end = 10 };
    try std.testing.expect(entity.isValid(10));
    try std.testing.expect(!entity.isValid(9));
    try std.testing.expect(!entity.contains(4));
    try std.testing.expect(entity.contains(5));
    try std.testing.expect(!entity.contains(10));
    try std.testing.expect(overlaps(entity, .{ .raw_start = 9, .raw_end = 12 }));
    try std.testing.expect(!overlaps(entity, .{ .raw_start = 10, .raw_end = 12 }));
    try std.testing.expect(containsSpan(entity, .{ .raw_start = 5, .raw_end = 9 }));
}