/cli/src/commands/albums.zig at a363d62423976daad582c086ca9a12719f926426

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

const std = @import("std");
const clap = @import("clap");
const core = @import("core");

const connection = @import("../connection.zig");
const State = @import("../State.zig");
const ExitCode = @import("../exit.zig").ExitCode;

const OutputFormat = enum {
    text,
    tsv,
    jsonl,
};

const parser = .{
    .format = clap.parsers.enumeration(OutputFormat),
};

const params = clap.parseParamsComptime(
    \\-h, --help Prints this message to stdout and exits.
    \\--header Whether emits header row (only on --format=tsv)
    \\-f, --format <format> Output format.
    \\Available values are:
    \\* text ... Plain text format for human consumption.
    \\* tsv ... TSV (tab-separated values).
    \\* jsonl ... Newline delimited list of JSON documents.
    \\
);

pub fn run(allocator: std.mem.Allocator, iter: *std.process.ArgIterator) ExitCode {
    var diag = clap.Diagnostic{};
    var res = clap.parseEx(clap.Help, &params, parser, iter, .{
        .diagnostic = &diag,
        .allocator = allocator,
    }) catch |err| {
        diag.report(std.io.getStdErr().writer(), err) catch {};
        return ExitCode.incorrect_usage;
    };
    defer res.deinit();

    if (res.args.help > 0) {
        clap.help(std.io.getStdOut().writer(), clap.Help, &params, .{}) catch {
            return ExitCode.stdout_write_failed;
        };
        return ExitCode.ok;
    }

    const conn = connection.make(allocator) catch |err| {
        std.log.err("Unable to establish a connection: {s}", .{@errorName(err)});
        return switch (err) {
            error.OutOfMemory => ExitCode.out_of_memory,
            else => ExitCode.not_ok,
        };
    };
    defer conn.release();

    while (true) {
        const ev = conn.getEvent() orelse {
            std.log.err("Got empty event, terminating", .{});
            return ExitCode.not_ok;
        };
        defer ev.release();

        switch (ev.internal.payload) {
            .connection_error => |err_ev| {
                std.log.err("Failed to read event: {s}", .{@tagName(err_ev.code)});
                return ExitCode.not_ok;
            },
            .connected => {
                break;
            },
            else => {
                continue;
            },
        }
    }

    const loop_thread = std.Thread.spawn(.{}, consumeEvent, .{conn}) catch |err| {
        std.log.err("Failed to spawn message read thread: {s}", .{@errorName(err)});
        return ExitCode.not_ok;
    };
    defer {
        conn.disconnect();
        loop_thread.join();
    }

    const browse_result = conn.requestBrowse(.albums, null, null, false) orelse {
        std.log.err("Failed to browse albums: OutOfMemory", .{});
        return ExitCode.out_of_memory;
    };
    defer browse_result.release();

    if (browse_result.code != .ok) {
        std.log.err("Failed to browse albums: {s}", .{@tagName(browse_result.code)});
        return if (browse_result.code == .out_of_memory) ExitCode.out_of_memory else ExitCode.not_ok;
    }

    if (browse_result.action != .list) {
        std.log.err("Expected `list` response, found `{s}`", .{@tagName(browse_result.action)});
        return ExitCode.not_ok;
    }

    const list = browse_result.internal.payload.list;
    const stdout = std.io.getStdOut().writer();

    switch (res.args.format orelse .text) {
        .text => {
            for (list.items_ptr[0..list.items_len]) |item| {
                std.fmt.format(
                    stdout,
                    "Title=\"{s}\" Artist=\"{s}\"\n",
                    .{ item.title, item.subtitle orelse "" },
                ) catch |err| {
                    std.log.err("Failed to write to stdout: {s}", .{@errorName(err)});
                    return ExitCode.stdout_write_failed;
                };
            }
        },
        .tsv => {
            if (res.args.header > 0) {
                stdout.writeAll("Title\tArtist\n") catch |err| {
                    std.log.err("Failed to write to stdout: {s}", .{@errorName(err)});
                    return ExitCode.stdout_write_failed;
                };
            }

            for (list.items_ptr[0..list.items_len]) |item| {
                stdout.print(
                    "{s}\t{s}\n",
                    .{ item.title, item.subtitle orelse "" },
                ) catch |err| {
                    std.log.err("Failed to write to stdout: {s}", .{@errorName(err)});
                    return ExitCode.stdout_write_failed;
                };
            }
        },
        .jsonl => {
            for (list.items_ptr[0..list.items_len]) |item| {
                stdout.print("{}\n", .{
                    std.json.fmt(ItemPrinter{ .item = item }, .{ .whitespace = .minified }),
                }) catch |err| {
                    std.log.err("Failed to write to stdout: {s}", .{@errorName(err)});
                    return ExitCode.stdout_write_failed;
                };
            }
        },
    }

    return ExitCode.ok;
}

const ItemPrinter = struct {
    item: *const core.browse.Item,

    pub fn jsonStringify(self: *const ItemPrinter, jws: anytype) !void {
        try jws.beginObject();

        try jws.objectField("title");
        try jws.write(self.item.title);

        try jws.objectField("artist");
        try jws.write(self.item.subtitle);

        if (self.item.image_key) |image_key| {
            try jws.objectField("image_key");
            try jws.write(image_key);
        }

        try jws.endObject();
    }
};

fn consumeEvent(conn: *core.connection.Connection) void {
    const ev = conn.getEvent() orelse {
        return;
    };
    defer ev.release();
}