const std = @import("std");

const root = @import("root.zig");
const Lexer = root.Lexer;
const Token = root.Token;

pub const Identifier = enum {
    public,
    private,

    pub inline fn tokenize(comptime lexer: *Lexer) Lexer.Error!void {
        comptime {
            defer lexer.revert();

            const token = tok: {
                if (lexer.peekChar() == '#') {
                    const t = lexer.start(.{ .identifier = .private });
                    lexer.skip() catch unreachable;
                    break :tok t;
                } else {
                    break :tok lexer.start(.{ .identifier = .public });
                }
            };

            switch (try lexer.consume()) {
                'a'...'z', 'A'...'Z', '_' => {},
                else => return Lexer.Error.UnexpectedToken,
            }

            while (lexer.peekChar()) |ch| {
                switch (ch) {
                    'a'...'z', 'A'...'Z', '0'...'9', '_' => {},
                    else => break,
                }

                try lexer.skip();
            }

            lexer.commit(token);
        }
    }
};

test "simple" {
    {
        comptime var lexer: Lexer = .init("some_literal9");
        try Identifier.tokenize(&lexer);
        try std.testing.expectEqual(1, lexer.tokens.len);
        try std.testing.expectEqual(13, lexer.tokens[0].slice.len);
    }

    {
        comptime var lexer: Lexer = .init("#some_literal9");
        try Identifier.tokenize(&lexer);
        try std.testing.expectEqual(1, lexer.tokens.len);
        try std.testing.expectEqual(14, lexer.tokens[0].slice.len);
    }
}