yaes/src/main.zig

const std = @import("std");

const Config = @import("./Config.zig");
const lj = @import("./labjack.zig");
const RotCtl = @import("./RotCtl.zig");

const udev = @import("udev_rules");

const log = std.log.scoped(.main);

fn printStderr(comptime fmt: []const u8, args: anytype) void {
    std.debug.print(fmt ++ "\n", args);
}

pub fn main() !u8 {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const args = std.process.argsAlloc(allocator) catch {
        printStderr("Couldn't allocate arguments array", .{});
        return 1;
    };
    defer std.process.argsFree(allocator, args);

    if (args.len < 1) {
        printStderr("No arguments at all?", .{});
        return 1;
    }

    const exename = std.fs.path.basename(args[0]);

    if (args.len < 2) {
        printHelp(exename, .main);
        return 1;
    } else if (std.mem.eql(u8, args[1], commands.install_udev)) {
        if (args.len > 3) {
            printHelp(exename, .install_udev);
            return 1;
        }

        return installUdevRules(if (args.len == 3) args[2] else null);
    } else if (std.mem.eql(u8, args[1], commands.write_config)) {
        if (args.len > 3) {
            printHelp(exename, .write_config);
            return 1;
        }

        Config.loadDefault(allocator);
        return writeDefaultConfig(if (args.len == 3) args[2] else null);
    } else if (std.mem.eql(u8, args[1], commands.run)) {
        if (args.len > 3) {
            printHelp(exename, .run);
            return 1;
        }
        blk: {
            const confpath = if (args.len == 3) args[2] else "yaes.json";
            const conf_file = std.fs.cwd().openFile(confpath, .{}) catch {
                log.warn("Could not load config file '{s}'. Using default config.", .{confpath});
                Config.loadDefault(allocator);
                break :blk;
            };
            defer conf_file.close();

            Config.load(allocator, conf_file.reader(), std.io.getStdErr().writer()) catch |err| {
                log.err("Could not parse config file '{s}': {s}.", .{ confpath, @errorName(err) });
                return 1;
            };
        }
        defer Config.destroy(allocator);

        const ver = lj.getDriverVersion();
        std.debug.print("Driver version: {d}\n", .{ver});

        RotCtl.run(allocator) catch |err| {
            log.err("rotator controller ceased unexpectedly! {s}", .{@errorName(err)});
            return 1;
        };

        return 0;
    } else if (std.mem.eql(u8, args[1], commands.help)) {
        if (args.len != 3) {
            printHelp(exename, .help);
            return 1;
        }

        inline for (@typeInfo(@TypeOf(commands)).Struct.fields) |field| {
            if (std.mem.eql(u8, args[2], @field(commands, field.name))) {
                printHelp(exename, @field(HelpTag, field.name));
                return 0;
            }
        } else {
            printHelp(exename, .help);
            return 1;
        }
    } else {
        printHelp(exename, .main);
        return 1;
    }
}

fn installUdevRules(outpath: ?[]const u8) u8 {
    const rules_path = outpath orelse "/etc/udev/rules.d";
    var rules_d = std.fs.cwd().openDir(rules_path, .{}) catch |err| {
        printStderr(
            "could not open udev rules path '{s}': {s}",
            .{ rules_path, @errorName(err) },
        );
        return 1;
    };
    defer rules_d.close();

    rules_d.writeFile(.{ .sub_path = udev.rules_filename, .data = udev.rules }) catch |err| {
        printStderr(
            "could not write rules file '{s}{s}{s}': {s}",
            .{
                rules_path,
                if (rules_path.len == 0)
                    "./"
                else if (rules_path[rules_path.len - 1] == '/')
                    ""
                else
                    "/",
                udev.rules_filename,
                @errorName(err),
            },
        );
        return 1;
    };

    return 0;
}

fn writeDefaultConfig(outarg: ?[]const u8) u8 {
    const outpath = outarg orelse "yaes.json";

    const outfile = std.fs.cwd().createFile(outpath, .{}) catch |err| {
        printStderr("Could not write config file '{s}': {s}", .{ outpath, @errorName(err) });
        return 1;
    };
    defer outfile.close();

    std.json.stringify(Config.global.*, .{ .whitespace = .indent_4 }, outfile.writer()) catch |err| {
        printStderr("Could not serialize config file '{s}': {s}", .{ outpath, @errorName(err) });
        return 1;
    };

    printStderr("config written to {s}", .{outpath});
    return 0;
}

fn printHelp(exename: []const u8, comptime cmd: HelpTag) void {
    switch (cmd) {
        .main => {
            printStderr(command_help.main, .{ .exename = exename });
            inline for (@typeInfo(@TypeOf(commands)).Struct.fields) |field| {
                printStderr(
                    "  {s: <" ++ max_command_len ++ "}  {s}",
                    .{ @field(commands, field.name), @field(command_help, field.name).brief },
                );
            }
            printStderr("", .{});
        },
        .help => {
            printStderr(command_help.help.full, .{ .exename = exename, .cmdname = "help" });
            inline for (@typeInfo(@TypeOf(commands)).Struct.fields) |field| {
                printStderr(
                    "               - {s}",
                    .{@field(commands, field.name)},
                );
            }
            printStderr("", .{});
        },
        else => {
            printStderr(
                @field(command_help, @tagName(cmd)).full,
                .{ .exename = exename, .cmdname = @field(commands, @tagName(cmd)) },
            );
            printStderr("", .{});
        },
    }
}

const HelpTag = std.meta.FieldEnum(@TypeOf(command_help));

const commands = .{
    .install_udev = "install-udev-rules",
    .write_config = "write-default-config",
    .run = "run",
    .calibrate = "calibrate",
    .help = "help",
};

const max_command_len: []const u8 = blk: {
    var len: usize = 0;
    for (@typeInfo(@TypeOf(commands)).Struct.fields) |field|
        if (@field(commands, field.name).len > len) {
            len = @field(commands, field.name).len;
        };
    break :blk std.fmt.comptimePrint("{d}", .{len});
};

const command_help = .{
    .main =
    \\Usage: {[exename]s} <command> [arguments...]
    \\
    \\  Calibrate/Control a Yaesu G-5500DC rotator with a LabJack U12.
    \\
    \\Commands:
    ,
    .install_udev = .{
        .brief = "Install a udev rules file for the LabJack U12",
        .full =
        \\Usage: {[exename]s} {[cmdname]s} [<rules_dir>]
        \\
        \\  Install a udev rules file for the LabJack U12, which allows unprivileged access to the device on
        \\  Linux-based operating systems.
        \\
        \\Arguments:
        \\  rules_dir  [Optional] The path to the udev rules directory inside which the rules file will be
        \\             written. (Default: /etc/udev/rules.d)
        ,
    },
    .write_config = .{
        .brief = "Write the default configuration to a file",
        .full =
        \\Usage: {[exename]s} {[cmdname]s} [<config_file>]
        \\
        \\  Write the built-in configuration defaults to a file. Useful as a starting point for creating a
        \\  custom configuration.
        \\
        \\Arguments:
        \\  config_file  [Optional] the path of the file to write. (Default: ./yaes.json)
        ,
    },
    .run = .{
        .brief = "Run the rotator with a hamlib-compatible TCP interface",
        .full =
        \\Usage: {[exename]s} {[cmdname]s} [<config_file>]
        \\
        \\  Expose a hamlib (rotctld)-compatible TCP interface through which the rotator can be controlled.
        \\  This listens on localhost port 4533 by default. Only a subset of the rotctld commands are
        \\  actually supported. A brief list of supported commands:
        \\
        \\    P, set_pos <az> <el> - point the rotator to the given azimuth and elevation
        \\    p, get_pos           - return the rotator's current azimuth and elevation
        \\    S, stop              - stop moving the rotator if it is moving
        \\    K, park              - move the rotator to its parking posture (defined by the config)
        \\    q, Q, quit           - [nonstandard] stop the rotator control loop and exit
        \\
        \\Arguments:
        \\  config_file  [Optional] the name of the config file to load. If this file does not exist, then
        \\               the built-in defaults will be used. (Default: ./yaes.json)
        ,
    },
    .calibrate = .{
        .brief = "Calibrate the rotator's feedback or its orientation to geodetic North",
        .full =
        \\Usage: {[exename]s} {[cmdname]s} <routine> [<config_file>]
        \\
        \\  Perform a calibration routine and write an updated configuration with its results.
        \\
        \\Arguments:
        \\  routine      Must be one of `feedback` or `orientation`. The different calibration routines have
        \\               different requirements. `orientation` calibration is a sun-pointing-based routine and
        \\               should be performed after `feedback` calibration is complete.
        \\  config_file  [Optional] the path of a config file to load. This file will be updated with the
        \\               results of the calibration process. If omitted and the configuration file does not
        \\               exist, then the default configuration will be used. (Default: ./yaes.json)
        ,
    },
    .help = .{
        .brief = "Print detailed help for a given command",
        .full =
        \\Usage: {[exename]s} {[cmdname]s} <command>
        \\
        \\  Print information on how to use a command and exit.
        \\
        \\Arguments:
        \\  command   The name of the command to print information about. Must be one of the following:
        ,
    },
};