const std = @import("std");
const lang = @import("lang.zig");
const images = @import("image.zig");
const plugin = @import("plugin.zig");
const custom = @import("custom.zig");
const magick = @import("magick.zig");

const Position = plugin.Position;
const ParamList = plugin.ParamList;
const ParamMap = plugin.ParamMap;

const Image = images.Image;

pub const RunError = error{
    UnknownCommand,
    NoBMP,
    ImageRequired,
};

pub const Runner = struct {
    allocator: *std.mem.Allocator,

    /// The currently opened image in the runner
    image: ?*Image = null,

    /// If the runner is in REPL mode
    repl: bool = false,

    pub fn init(allocator: *std.mem.Allocator, repl: bool) Runner {
        return Runner{
            .allocator = allocator,
            .repl = repl,
        };
    }

    pub fn deinit(self: *Runner) void {
        if (self.image) |image| {
            image.close();
        }
    }

    pub fn clone(self: *Runner) !Runner {
        var cloned_image = if (self.image) |image| try image.clone() else null;
        return Runner{ .allocator = self.allocator, .image = cloned_image };
    }

    fn resolveArg(self: *Runner, load_path: []const u8) ![]const u8 {
        if (load_path[0] == ':') {
            // parse the index from 1 to end
            var index = try std.fmt.parseInt(usize, load_path[1..], 10);

            // don't care about the 'repl' being prepended when we're in repl
            if (self.repl) index += 1;

            var args_it = std.process.args();
            _ = args_it.skip();

            var i: usize = 0;
            while (i <= index) : (i += 1) {
                _ = args_it.skip();
            }

            const arg = try (args_it.next(self.allocator) orelse @panic("expected argument"));

            return arg;
        } else {
            return load_path;
        }
    }

    fn resolveArgPath(self: *Runner, path_or_argidx: []const u8) ![]const u8 {
        const path = try self.resolveArg(path_or_argidx);
        const resolved_path = try std.fs.path.resolve(
            self.allocator,
            &[_][]const u8{path},
        );

        return resolved_path;
    }

    fn loadCmd(self: *Runner, path_or_argidx: []const u8) !void {
        var load_path = try self.resolveArgPath(path_or_argidx);
        std.debug.warn("\tload path: {}\n", .{load_path});

        // we could use ImageMagick to convert from X to BMP
        // but i can't find an easy way to do things in memory.

        // the upside is that this allows some pre-processing by the user
        // before loading the file into scritcher. for example, you can start
        // krita/gimp and make it export a bmp and while in the program you can
        // apply filters, etc.
        if (!std.mem.endsWith(u8, load_path, ".bmp") and !std.mem.endsWith(u8, load_path, ".ppm")) {
            std.debug.warn("Only BMP files are allowed to be loaded.\n", .{});
            return RunError.NoBMP;
        }

        // we don't copy load_path into a temporary file because we're already
        // loading it under the SFM_READ mode, which won't cause any destructive
        // operations on the file.
        self.image = try Image.open(self.allocator, load_path);
    }

    fn getImage(self: *Runner) !*Image {
        if (self.image) |image| {
            return image;
        } else {
            std.debug.warn("image is required!\n", .{});
            return RunError.ImageRequired;
        }
    }

    fn makeGlitchedPath(self: *Runner) ![]const u8 {
        // we want to transform basename, if it is "x.bmp" to "x_gN.bmp", where
        // N is the maximum non-used integer.
        var image = try self.getImage();

        const basename = std.fs.path.basename(image.path);
        const dirname = std.fs.path.dirname(image.path).?;

        var dir = try std.fs.cwd().openDir(dirname, .{ .iterate = true });
        defer dir.close();

        const period_idx = std.mem.lastIndexOf(u8, basename, ".").?;
        const extension = basename[period_idx..basename.len];

        // starts_with would be "x_g", we want to find all files in the directory
        // that start with that name.
        const starts_with = try std.fmt.allocPrint(self.allocator, "{}_g", .{
            basename[0..period_idx],
        });
        defer self.allocator.free(starts_with);

        var max: usize = 0;

        var it = dir.iterate();

        while (try it.next()) |entry| {
            switch (entry.kind) {
                .File => blk: {
                    if (!std.mem.startsWith(u8, entry.name, starts_with)) break :blk {};

                    // we want to get the N in x_gN.ext
                    const entry_gidx = std.mem.lastIndexOf(u8, entry.name, "_g").?;

                    const entry_pidx_opt = std.mem.lastIndexOf(u8, entry.name, ".");
                    if (entry_pidx_opt == null) break :blk {};

                    const entry_pidx = entry_pidx_opt.?;

                    // if N isn't a number, we just ignore that file
                    const idx_str = entry.name[entry_gidx + 2 .. entry_pidx];
                    const idx = std.fmt.parseInt(usize, idx_str, 10) catch |err| {
                        break :blk {};
                    };

                    if (idx > max) max = idx;
                },
                else => {},
            }
        }

        const out_path = try std.fmt.allocPrint(self.allocator, "{}/{}{}{}", .{
            dirname,
            starts_with,
            max + 1,
            extension,
        });

        return out_path;
    }

    fn quicksaveCmd(self: *Runner) !void {
        var image = try self.getImage();
        const out_path = try self.makeGlitchedPath();
        try image.saveTo(out_path);
    }

    fn runQSCmd(self: *Runner, program: []const u8) !void {
        var image = try self.getImage();
        const out_path = try self.makeGlitchedPath();
        try image.saveTo(out_path);

        var proc = try std.ChildProcess.init(
            &[_][]const u8{ program, out_path },
            self.allocator,
        );
        defer proc.deinit();

        std.debug.warn("running '{} {}'\n", .{ program, out_path });
        _ = try proc.spawnAndWait();
    }

    /// Run the http://lv2plug.in/plugins/eg-amp plugin over the file.
    fn ampCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://lv2plug.in/plugins/eg-amp", pos, params);
    }

    fn rFlangerCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/retroFlange", pos, params);
    }

    fn eqCmd(self: *Runner, position: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/dj_eq_mono", position, params);
    }

    fn phaserCmd(self: *Runner, position: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/lfoPhaser", position, params);
    }

    fn mbeqCmd(self: *Runner, position: Position, bands: []const f32) !void {
        var image = try self.getImage();
        var params = ParamList.init(self.allocator);
        defer params.deinit();

        for (bands) |band_value, idx| {
            var sym = try std.fmt.allocPrint(self.allocator, "band_{}", .{idx + 1});
            try params.append(plugin.Param{
                .sym = sym,
                .value = band_value,
            });
        }

        try image.runPlugin("http://plugin.org.uk/swh-plugins/mbeq", position, params);
    }

    fn chorusCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/multivoiceChorus", pos, params);
    }

    fn pitchScalerCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/pitchScaleHQ", pos, params);
    }

    fn reverbCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://invadarecords.com/plugins/lv2/erreverb/mono", pos, params);
    }

    fn highpassCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://invadarecords.com/plugins/lv2/filter/hpf/mono", pos, params);
    }

    fn delayCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/delayorama", pos, params);
    }

    fn vinylCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/vynil", pos, params);
    }

    fn revDelayCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/revdelay", pos, params);
    }

    fn noiseCmd(self: *Runner, pos: Position, map: *ParamMap) !void {
        var image = try self.getImage();
        try image.runCustomPlugin(custom.RandomNoise, pos, *ParamMap, map);
    }

    fn wildNoiseCmd(self: *Runner, pos: Position, map: *ParamMap) !void {
        var image = try self.getImage();
        try image.runCustomPlugin(custom.WildNoise, pos, *ParamMap, map);
    }

    fn writeCmd(self: *Runner, pos: Position, map: *ParamMap) !void {
        var image = try self.getImage();
        try image.runCustomPlugin(custom.Write, pos, *ParamMap, map);
    }

    fn embedCmd(self: *Runner, pos: Position, path: []const u8) !void {
        var image = try self.getImage();
        try image.runCustomPlugin(custom.Embed, pos, []const u8, path);
    }

    fn rotateCmd(
        self: *Runner,
        deg: f32,
        bgfill: []const u8,
    ) !void {
        var image = try self.getImage();
        var c_bgfill = try std.cstr.addNullByte(self.allocator, bgfill);
        defer self.allocator.free(c_bgfill);

        try magick.runRotate(image, deg, c_bgfill);
    }

    fn gateCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://hippie.lt/lv2/gate", pos, params);
    }

    fn detuneCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://drobilla.net/plugins/mda/Detune", pos, params);
    }

    fn overdriveCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://drobilla.net/plugins/mda/Overdrive", pos, params);
    }

    fn degradeCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://drobilla.net/plugins/mda/Degrade", pos, params);
    }

    fn repsychoCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://drobilla.net/plugins/mda/RePsycho", pos, params);
    }

    fn talkboxCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://drobilla.net/plugins/mda/TalkBox", pos, params);
    }

    fn dynCompCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://gareus.org/oss/lv2/darc#mono", pos, params);
    }

    fn foverdriveCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/foverdrive", pos, params);
    }

    fn thruZeroCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://drobilla.net/plugins/mda/ThruZero", pos, params);
    }

    fn gverbCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/gverb", pos, params);
    }

    fn invertCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/inv", pos, params);
    }

    fn tapedelayCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/tapeDelay", pos, params);
    }

    fn moddelayCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://plugin.org.uk/swh-plugins/modDelay", pos, params);
    }

    fn multichorusCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://calf.sourceforge.net/plugins/MultiChorus", pos, params);
    }

    fn saturatorCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://calf.sourceforge.net/plugins/Saturator", pos, params);
    }

    fn vintagedelayCmd(self: *Runner, pos: Position, params: ParamList) !void {
        var image = try self.getImage();
        try image.runPlugin("http://calf.sourceforge.net/plugins/VintageDelay", pos, params);
    }

    fn executeLV2Command(self: *@This(), command: var) !void {
        const pos = plugin.Position{
            .split = command.split,
            .index = command.index,
        };

        var params = ParamList.init(self.allocator);
        defer params.deinit();

        const typ = @TypeOf(command);

        inline for (@typeInfo(typ).Struct.fields) |cmd_field| {
            // ignore fields that can't be symbols for lv2 execution
            comptime {
                if (std.mem.eql(u8, cmd_field.name, "base") or
                    std.mem.eql(u8, cmd_field.name, "split") or
                    std.mem.eql(u8, cmd_field.name, "index"))
                {
                    continue;
                }
            }

            try params.append(plugin.Param{
                .sym = cmd_field.name,
                .value = @field(command, cmd_field.name),
            });
        }

        var image = try self.getImage();
        try image.runPlugin(typ.lv2_url, pos, params);
    }

    fn newRunCommandSingle(
        self: *@This(),
        cmd: lang.NewCommand,
        comptime tag: lang.NewCommand.Tag,
    ) !void {
        comptime const typ = lang.NewCommand.tagToType(tag);
        const command = cmd.cast(typ).?;
        inline for (@typeInfo(typ).Struct.decls) |decl| {
            comptime {
                if (!std.mem.eql(u8, decl.name, "command_type")) {
                    continue;
                }
            }

            const ctype = typ.command_type;
            switch (ctype) {
                .lv2_command => try self.executeLV2Command(command.*),
                else => @panic("TODO support command type"),
            }
        }
    }

    fn newRunCommand(self: *@This(), cmd: lang.NewCommand) !void {
        //            .load => try self.newRunCommandSingle(cmd, .load),
        switch (cmd.tag) {
            .load => {
                const command = cmd.cast(lang.NewCommand.Load).?;
                try self.loadCmd(command.path);
            },
            .quicksave => {
                try self.quicksaveCmd();
            },
            .amp => try self.newRunCommandSingle(cmd, .amp),

            .rflanger => try self.newRunCommandSingle(cmd, .rflanger),
            .eq => try self.newRunCommandSingle(cmd, .eq),
            .phaser => try self.newRunCommandSingle(cmd, .phaser),
            // .mbeq => try self.newRunCommandSingle(cmd, .mbeq),
            // .chorus => try self.newRunCommandSingle(cmd, .chorus),
            // .pitchscaler => try self.newRunCommandSingle(cmd, .pitchscaler),
            // .reverb => try self.newRunCommandSingle(cmd, .reverb),
            // .highpass => try self.newRunCommandSingle(cmd, .highpass),
            // .delay => try self.newRunCommandSingle(cmd, .delay),
            // .vinyl => try self.newRunCommandSingle(cmd, .vinyl),
            // .revdelay => try self.newRunCommandSingle(cmd, .revdelay),
            // .gate => try self.newRunCommandSingle(cmd, .gate),
            // .detune => try self.newRunCommandSingle(cmd, .detune),
            // .overdrive => try self.newRunCommandSingle(cmd, .overdrive),
            // .degrade => try self.newRunCommandSingle(cmd, .degrade),
            // .repsycho => try self.newRunCommandSingle(cmd, .repsycho),
            // .talkbox => try self.newRunCommandSingle(cmd, .talkbox),
            // .dyncomp => try self.newRunCommandSingle(cmd, .dyncomp),
            // .thruzero => try self.newRunCommandSingle(cmd, .thruzero),
            // .foverdrive => try self.newRunCommandSingle(cmd, .foverdrive),
            // .gverb => try self.newRunCommandSingle(cmd, .gverb),
            // .invert => try self.newRunCommandSingle(cmd, .invert),
            // .tapedelay => try self.newRunCommandSingle(cmd, .tapedelay),
            // .moddelay => try self.newRunCommandSingle(cmd, .moddelay),
            // .multichorus => try self.newRunCommandSingle(cmd, .multichorus),
            // .saturator => try self.newRunCommandSingle(cmd, .saturator),
            // .vintagedelay => try self.newRunCommandSingle(cmd, .vintagedelay),

            else => {
                std.debug.warn("TODO support {}\n", .{@tagName(cmd.tag)});
                @panic("TODO support tag");
            },
        }
    }

    fn runCommand(self: *Runner, cmd: *lang.Command) !void {
        var params = ParamList.init(self.allocator);
        defer params.deinit();

        var map = ParamMap.init(self.allocator);
        defer map.deinit();

        return switch (cmd.command) {
            .Noop => {},
            .Load => blk: {
                var path = cmd.args.items[0];
                try self.loadCmd(path);

                // TODO is this needed?
                break :blk;
            },
            .Quicksave => try self.quicksaveCmd(),
            .RunQS => try self.runQSCmd(cmd.args.items[0]),

            .Phaser => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParam(&params, "lfo_rate");
                try cmd.appendParam(&params, "lfo_depth");
                try cmd.appendParam(&params, "fb");
                try cmd.appendParam(&params, "spread");

                try self.phaserCmd(pos, params);
            },

            .Mbeq => blk: {
                const pos = try cmd.consumePosition();
                const bands = try cmd.floatArgMany(self.allocator, 2, 15, @as(f32, 0));
                defer self.allocator.free(bands);

                try self.mbeqCmd(pos, bands);
            },

            .Chorus => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParam(&params, "voices");
                try cmd.appendParam(&params, "delay_base");
                try cmd.appendParam(&params, "voice_spread");
                try cmd.appendParam(&params, "detune");
                try cmd.appendParam(&params, "law_freq");
                try cmd.appendParam(&params, "attendb");

                try self.chorusCmd(pos, params);
            },

            .PitchScaler => blk: {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "mult");
                try self.pitchScalerCmd(pos, params);
            },

            .Reverb => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParam(&params, "roomLength");
                try cmd.appendParam(&params, "roomWidth");
                try cmd.appendParam(&params, "roomHeight");
                try cmd.appendParam(&params, "sourceLR");
                try cmd.appendParam(&params, "sourceFB");
                try cmd.appendParam(&params, "listLR");
                try cmd.appendParam(&params, "listFB");
                try cmd.appendParam(&params, "hpf");
                try cmd.appendParam(&params, "warmth");
                try cmd.appendParam(&params, "diffusion");

                try self.reverbCmd(pos, params);
            },

            .Highpass => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParam(&params, "freq");
                try cmd.appendParam(&params, "gain");
                try cmd.appendParam(&params, "noClip");

                try self.highpassCmd(pos, params);
            },

            .Delay => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParam(&params, "seed");
                try cmd.appendParam(&params, "gain");
                try cmd.appendParam(&params, "feedback_pc");
                try cmd.appendParam(&params, "tap_count");
                try cmd.appendParam(&params, "first_delay");
                try cmd.appendParam(&params, "delay_range");
                try cmd.appendParam(&params, "delay_scale");
                try cmd.appendParam(&params, "delay_rand_pc");
                try cmd.appendParam(&params, "gain_scale");
                try cmd.appendParam(&params, "wet");

                try self.delayCmd(pos, params);
            },

            .Vinyl => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParam(&params, "year");
                try cmd.appendParam(&params, "rpm");
                try cmd.appendParam(&params, "warp");
                try cmd.appendParam(&params, "click");
                try cmd.appendParam(&params, "wear");

                try self.vinylCmd(pos, params);
            },

            .RevDelay => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParam(&params, "delay_time");
                try cmd.appendParam(&params, "dry_level");
                try cmd.appendParam(&params, "wet_level");
                try cmd.appendParam(&params, "feedback");
                try cmd.appendParam(&params, "xfade_samp");

                try self.revDelayCmd(pos, params);
            },

            .Noise => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParamMap(&map, "seed");
                try cmd.appendParamMap(&map, "fill_bytes");

                try self.noiseCmd(pos, &map);
            },

            .WildNoise => blk: {
                const pos = try cmd.consumePosition();

                try cmd.appendParamMap(&map, "seed");
                try cmd.appendParamMap(&map, "fill_bytes");

                try self.wildNoiseCmd(pos, &map);
            },

            .Write => blk: {
                const pos = try cmd.consumePosition();
                try cmd.appendParamMap(&map, "data");
                try self.writeCmd(pos, &map);
            },

            .Embed => blk: {
                const pos = try cmd.consumePosition();
                const path = cmd.args.items[2];
                try self.embedCmd(pos, path);
            },

            .Rotate => blk: {
                const deg = try cmd.floatArgAt(0);
                const bgfill = try cmd.argAt(1);
                try self.rotateCmd(deg, bgfill);
            },

            .Gate => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "switch");
                try cmd.appendParam(&params, "threshold");
                try cmd.appendParam(&params, "attack");
                try cmd.appendParam(&params, "hold");
                try cmd.appendParam(&params, "decay");
                try cmd.appendParam(&params, "gaterange");
                try self.gateCmd(pos, params);
            },

            .Detune => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "detune");
                try cmd.appendParam(&params, "mix");
                try cmd.appendParam(&params, "output");
                try cmd.appendParam(&params, "latency");
                try self.detuneCmd(pos, params);
            },

            .Overdrive => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "drive");
                try cmd.appendParam(&params, "muffle");
                try cmd.appendParam(&params, "output");
                try self.overdriveCmd(pos, params);
            },

            .Degrade => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "headroom");
                try cmd.appendParam(&params, "quant");
                try cmd.appendParam(&params, "rate");
                try cmd.appendParam(&params, "post_filt");
                try cmd.appendParam(&params, "non_lin");
                try cmd.appendParam(&params, "output");
                try self.degradeCmd(pos, params);
            },

            .RePsycho => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "tune");
                try cmd.appendParam(&params, "fine");
                try cmd.appendParam(&params, "decay");
                try cmd.appendParam(&params, "thresh");
                try cmd.appendParam(&params, "hold");
                try cmd.appendParam(&params, "mix");
                try cmd.appendParam(&params, "quality");
                try self.repsychoCmd(pos, params);
            },

            .TalkBox => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "wet");
                try cmd.appendParam(&params, "dry");
                try cmd.appendParam(&params, "carrier");
                try cmd.appendParam(&params, "quality");
                try self.talkboxCmd(pos, params);
            },

            .DynComp => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "enable");
                try cmd.appendParam(&params, "hold");
                try cmd.appendParam(&params, "inputgain");
                try cmd.appendParam(&params, "threshold");
                try cmd.appendParam(&params, "ratio");
                try cmd.appendParam(&params, "attack");
                try cmd.appendParam(&params, "release");
                try cmd.appendParam(&params, "gain_min");
                try cmd.appendParam(&params, "gain_max");
                try cmd.appendParam(&params, "rms");
                try self.dynCompCmd(pos, params);
            },

            .ThruZero => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "rate");
                try cmd.appendParam(&params, "mix");
                try cmd.appendParam(&params, "feedback");
                try cmd.appendParam(&params, "depth_mod");
                try self.thruZeroCmd(pos, params);
            },

            .Foverdrive => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "drive");
                try self.foverdriveCmd(pos, params);
            },

            .Gverb => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "roomsize");
                try cmd.appendParam(&params, "revtime");
                try cmd.appendParam(&params, "damping");
                try cmd.appendParam(&params, "inputbandwidth");
                try cmd.appendParam(&params, "drylevel");
                try cmd.appendParam(&params, "earlylevel");
                try cmd.appendParam(&params, "taillevel");
                try self.gverbCmd(pos, params);
            },

            .Invert => {
                const pos = try cmd.consumePosition();
                try self.gverbCmd(pos, params);
            },

            .TapeDelay => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "speed");
                try cmd.appendParam(&params, "da_db");

                try cmd.appendParam(&params, "t1d");
                try cmd.appendParam(&params, "t1a_db");

                try cmd.appendParam(&params, "t2d");
                try cmd.appendParam(&params, "t2a_db");

                try cmd.appendParam(&params, "t3d");
                try cmd.appendParam(&params, "t3a_db");

                try cmd.appendParam(&params, "t4d");
                try cmd.appendParam(&params, "t4a_db");

                try self.tapedelayCmd(pos, params);
            },

            .ModDelay => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "base");
                try self.moddelayCmd(pos, params);
            },

            .MultiChorus => {
                const pos = try cmd.consumePosition();
                try cmd.appendParam(&params, "min_delay");
                try cmd.appendParam(&params, "mod_depth");
                try cmd.appendParam(&params, "mod_rate");
                try cmd.appendParam(&params, "stereo");
                try cmd.appendParam(&params, "voices");
                try cmd.appendParam(&params, "vphase");
                try cmd.appendParam(&params, "amount");
                try cmd.appendParam(&params, "dry");
                try cmd.appendParam(&params, "freq");
                try cmd.appendParam(&params, "freq2");
                try cmd.appendParam(&params, "q");
                try cmd.appendParam(&params, "overlap");
                try cmd.appendParam(&params, "level_in");
                try cmd.appendParam(&params, "level_out");
                try cmd.appendParam(&params, "lfo");
                try self.multichorusCmd(pos, params);
            },

            .Saturator => {
                const pos = try cmd.consumePosition();

                try cmd.appendParam(&params, "bypass");
                try cmd.appendParam(&params, "level_in");
                try cmd.appendParam(&params, "level_out");
                try cmd.appendParam(&params, "mix");
                try cmd.appendParam(&params, "drive");
                try cmd.appendParam(&params, "blend");
                try cmd.appendParam(&params, "lp_pre_freq");
                try cmd.appendParam(&params, "hp_pre_freq");
                try cmd.appendParam(&params, "lp_post_freq");
                try cmd.appendParam(&params, "hp_post_freq");
                try cmd.appendParam(&params, "p_freq");
                try cmd.appendParam(&params, "p_level");
                try cmd.appendParam(&params, "p_q");
                try cmd.appendParam(&params, "pre");
                try cmd.appendParam(&params, "post");
                try self.saturatorCmd(pos, params);
            },

            .VintageDelay => {
                const pos = try cmd.consumePosition();
                const PARAMS = [_][]const u8{
                    "level_in",
                    "level_out",
                    "subdiv",
                    "time_l",
                    "time_r",
                    "feedback",
                    "amount",
                    "mix_mode",
                    "medium",
                    "dry",
                    "width",
                    "fragmentation",
                    "pbeats",
                    "pfrag",
                    "timing",
                    "bpm",
                    "ms",
                    "hz",
                    "bpm_host",
                };

                inline for (PARAMS) |param| {
                    try cmd.appendParam(&params, param);
                }

                try self.vintagedelayCmd(pos, params);
            },

            else => blk: {
                std.debug.warn("Unsupported command: {}\n", .{cmd.command});
                break :blk RunError.UnknownCommand;
            },
        };
    }

    /// Run a list of commands.
    pub fn runCommands(
        self: *Runner,
        cmds: lang.CommandList,
        debug_flag: bool,
    ) !void {
        for (cmds.items) |cmd| {
            cmd.print();
            try self.newRunCommand(cmd.*);
        }
    }
};

test "running noop" {
    const allocator = std.heap.direct_allocator;
    var cmds = lang.CommandList.init(allocator);
    defer cmds.deinit();

    var cmd_ptr = try allocator.create(lang.Command);
    cmd_ptr.* = lang.Command{
        .command = .Noop,
        .args = lang.ArgList.init(allocator),
    };
    try cmds.append(cmd_ptr);

    var runner = Runner.init(allocator);
    defer runner.deinit();

    try runner.runCommands(cmds, false);
}