const std = @import("std");
const ink = @import("ink");
const fatal = std.process.fatal;

var stdin_buffer: [4096]u8 align(std.heap.page_size_min) = undefined;
var stdout_buffer: [4096]u8 align(std.heap.page_size_min) = undefined;
var stderr_buffer: [4096]u8 align(std.heap.page_size_min) = undefined;
var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
const max_src_size = std.math.maxInt(u32);

pub fn main() !void {
    const gpa = debug_allocator.allocator();
    defer _ = debug_allocator.deinit();

    var arena_allocator = std.heap.ArenaAllocator.init(gpa);
    defer arena_allocator.deinit();

    const arena = arena_allocator.allocator();
    const args = try std.process.argsAlloc(gpa);
    defer std.process.argsFree(gpa, args);

    if (args.len < 2) {
        fatal("Not enough arguments!", .{});
    }
    return mainArgs(gpa, arena, args);
}

fn mainArgs(
    gpa: std.mem.Allocator,
    arena: std.mem.Allocator,
    args_list: []const [:0]const u8,
) !void {
    var source_path: ?[]const u8 = null;
    var arg_index: usize = 1;
    var compile_only: bool = false;
    var dump_ast: bool = false;
    var dump_ir: bool = false;
    var dump_story: bool = false;
    var use_stdin: bool = false;
    var use_color: bool = false;

    while (arg_index < args_list.len) : (arg_index += 1) {
        const arg = args_list[arg_index];
        if (std.mem.startsWith(u8, arg, "-")) {
            if (std.mem.eql(u8, arg, "--stdin")) {
                use_stdin = true;
            } else if (std.mem.eql(u8, arg, "--compile-only")) {
                compile_only = true;
            } else if (std.mem.eql(u8, arg, "--dump-ast")) {
                dump_ast = true;
            } else if (std.mem.eql(u8, arg, "--dump-ir")) {
                dump_ir = true;
            } else if (std.mem.eql(u8, arg, "--dump-story")) {
                dump_story = true;
            } else if (std.mem.eql(u8, arg, "--use-color")) {
                use_color = true;
            } else {
                fatal("invalid parameter: '{s}'", .{arg});
            }
        } else if (source_path == null) {
            source_path = arg;
        } else {
            fatal("invalid positional argument: '{s}'", .{arg});
        }
    }

    const filename = source_path orelse "<STDIN>";
    const source_bytes: [:0]const u8 = s: {
        var f = if (source_path) |p| file: {
            break :file std.fs.cwd().openFile(p, .{}) catch |err| {
                fatal("unable to open file '{s}': {s}", .{ p, @errorName(err) });
            };
        } else std.fs.File.stdin();
        defer if (source_path != null) f.close();

        var file_reader: std.fs.File.Reader = f.reader(&stdin_buffer);
        break :s readSourceFile(arena, &file_reader) catch |err| {
            fatal("unable to load file '{s}': {s}", .{ filename, @errorName(err) });
        };
    };

    const stdout = std.fs.File.stdout();
    var stdout_writer = stdout.writer(&stdout_buffer);

    const stderr = std.fs.File.stderr();
    var stderr_writer = stderr.writer(&stderr_buffer);

    var story = ink.Story.loadFromString(gpa, source_bytes, .{
        .error_writer = &stderr_writer.interface,
        .dump_writer = &stdout_writer.interface,
        .use_color = use_color,
        .dump_ast = dump_ast,
        .dump_ir = dump_ir,
    }) catch |err| switch (err) {
        error.Fail => std.process.exit(1),
        else => |e| return e,
    };
    defer story.deinit();

    if (dump_story) {
        try story.dump(&stderr_writer.interface);
    }
    return if (!compile_only) run(gpa, &story);
}

fn run(gpa: std.mem.Allocator, story: *ink.Story) !void {
    const stdin = std.fs.File.stdin();
    var stdin_reader = stdin.reader(&stdin_buffer);

    while (!story.is_exited and story.can_advance) {
        while (story.can_advance) {
            const content_text = try story.advance(gpa);
            defer gpa.free(content_text);
            std.debug.print("{s}\n", .{content_text});
        }
        if (story.current_choices.items.len > 0) {
            for (story.current_choices.items, 0..) |*choice, index| {
                const choice_text = try choice.text.toOwnedSlice(gpa);
                defer gpa.free(choice_text);
                std.debug.print("[{d}]: {s}\n", .{ index + 1, choice_text });
            }
            std.debug.print("> ", .{});

            const input_line = try stdin_reader.interface.takeDelimiter('\n');
            if (input_line) |bytes| {
                const choice_index = try std.fmt.parseUnsigned(usize, bytes, 10);
                try story.selectChoiceIndex(if (choice_index == 0) 0 else choice_index - 1);
            }
        }
    }
}

fn readSourceFile(gpa: std.mem.Allocator, file_reader: *std.fs.File.Reader) ![:0]u8 {
    var buffer: std.ArrayListUnmanaged(u8) = .empty;
    defer buffer.deinit(gpa);

    if (file_reader.getSize()) |size| {
        const casted_size = std.math.cast(u32, size) orelse return error.StreamTooLong;
        try buffer.ensureTotalCapacityPrecise(gpa, casted_size + 1);
    } else |_| {}

    try file_reader.interface.appendRemaining(gpa, &buffer, .limited(max_src_size));

    const unsupported_boms = [_][]const u8{
        "\xff\xfe\x00\x00", // UTF-32 little endian
        "\xfe\xff\x00\x00", // UTF-32 big endian
        "\xfe\xff", // UTF-16 big endian
    };
    for (unsupported_boms) |bom| {
        if (std.mem.startsWith(u8, buffer.items, bom)) {
            return error.UnsupportedEncoding;
        }
    }
    if (std.mem.startsWith(u8, buffer.items, "\xff\xfe")) {
        if (buffer.items.len % 2 != 0) {
            return error.InvalidEncoding;
        }
        return std.unicode.utf16LeToUtf8AllocZ(gpa, @ptrCast(@alignCast(buffer.items))) catch |err| switch (err) {
            error.DanglingSurrogateHalf => error.UnsupportedEncoding,
            error.ExpectedSecondSurrogateHalf => error.UnsupportedEncoding,
            error.UnexpectedSecondSurrogateHalf => error.UnsupportedEncoding,
            else => |e| return e,
        };
    }
    return buffer.toOwnedSliceSentinel(gpa, 0);
}