const std = @import("std");

const pretty = @import("pretty").pretty;

const meta = @import("meta");

const st = @import("st");
const api = st.api;
const Client = st.http.Client;
const m = st.models;

const agent = @import("agent");
const Config = agent.config.Config;

pub const known_folders_config: @import("known-folders").KnownFolderConfig = .{
    .xdg_on_mac = true,
};

fn juicyMain(
    gpa: std.mem.Allocator,
    io: std.Io,
    config: *const Config,
    client: *Client,
) !void {
    var db = try agent.data.DB.open(gpa, config.db);
    defer db.deinit();

    // var register_f = try api.agent.register(client, "ALTAGOS", .ANCIENTS);
    // defer _ = register_f.cancel(io) catch {};

    // const register = try register_f.await(io);
    // defer register.deinit();

    // std.log.info("Registered agent\n{f}", .{pretty(register.value)});

    var af = try api.agent.own(client);
    defer _ = af.cancel(io) catch {};

    var fleet_f = try api.fleet.listShips(client, .{});
    defer _ = fleet_f.cancel(io) catch {};

    var traits = [_]m.systems.Waypoint.Trait{ .MARKETPLACE, .INDUSTRIAL, .OCEAN };
    var waypoints_f = try api.system.waypoints(
        client,
        (try m.parseSymbol("X1-TA72")).system,
        .{ .traits = &traits },
        .{},
    );
    defer _ = waypoints_f.cancel(io) catch {};

    const own = try af.await(io);
    defer own.deinit();

    const fleet = try fleet_f.await(io);
    defer fleet.deinit();

    const waypoints = try waypoints_f.await(io);
    defer waypoints.deinit();

    std.log.info("Agent: {f}", .{pretty(own.value)});
    std.log.info("Ships: {f}", .{pretty(fleet.value.data.?)});
    std.log.info("Waypoints with {any} traits: {f}", .{ traits, pretty(waypoints.value.data.?) });

    if (waypoints.value.data.?.len > 0) {
        var market_f = try api.system.market(
            client,
            waypoints.value.data.?[0].symbol.waypoint,
        );
        defer _ = market_f.cancel(io) catch {};

        const market = try market_f.await(io);
        defer market.deinit();

        std.log.info("Market: {f}", .{pretty(market.value.data.?)});
    }
}

pub fn main(init: std.process.Init) !void {
    const allocator = init.gpa;

    var io_impl: std.Io.Threaded = .init(allocator, .{
        .environ = init.minimal.environ,
    });
    defer io_impl.deinit();
    const io = io_impl.io();

    std.log.debug("Io threads: {}", .{io_impl.concurrent_limit.toInt() orelse 0});

    const config = try agent.config.load(io, allocator, init.environ_map);
    defer agent.config.free(allocator, config);

    var client = Client.init(allocator, io, .{
        .auth = config.auth,
    });
    defer client.deinit();

    try juicyMain(allocator, io, &config, &client);
}