QuasselClient/src/qtshit/utils/prettyPrintQVariant.zig

const std = @import("std");
const QVariant = @import("../types/QVariant.zig").QVariant;
const UserType = @import("../types/UserType.zig").UserType;
const BufferInfo = @import("../types/UserType.zig").BufferInfo;

const range = @import("../utils/RangeIter.zig").range;

pub fn print_indent_level(indentLevel: u64) void {
    var iter = range(u64, 0, indentLevel);
    while (iter.next()) |i| {
        std.debug.print("  ", .{});
    }
}

pub fn prettyPrintBufferInfo(value: BufferInfo, indentLevel: u64) void {
    std.debug.print("BufferInfo:\n", .{});
    print_indent_level(indentLevel + 1);
    std.debug.print("ID: {d}\n", .{value.ID});
    print_indent_level(indentLevel + 1);
    std.debug.print("NetworkID: {d}\n", .{value.NetworkID});
    print_indent_level(indentLevel + 1);
    std.debug.print("Type: {d}\n", .{value.Type});
    print_indent_level(indentLevel + 1);
    std.debug.print("Name: {s}\n", .{value.Name});
}

pub fn prettyPrintUserType(usertype: UserType, indentLevel: u64) void {
    switch (usertype) {
        .BufferId => |value| {
            std.debug.print("BufferId: {d}\n", .{value});
        },
        .IdentityId => |value| {
            std.debug.print("IdentityId: {d}\n", .{value});
        },
        .NetworkId => |value| {
            std.debug.print("NetworkId: {d}\n", .{value});
        },
        .MsgId => |value| {
            std.debug.print("MsgId: {d}\n", .{value});
        },
        .PeerPtr => |value| {
            std.debug.print("PeerPtr: {d}\n", .{value});
        },
        .IrcUser => |value| {
            std.debug.print("IrcUser:\n", .{});
            prettyPrintQVariantMap(value, indentLevel + 1);
        },
        .IrcChannel => |value| {
            std.debug.print("IrcChannel:\n", .{});
            prettyPrintQVariantMap(value, indentLevel + 1);
        },
        .Identity => |value| {
            std.debug.print("Identity:\n", .{});
            prettyPrintQVariantMap(value, indentLevel + 1);
        },
        .NetworkInfo => |value| {
            std.debug.print("NetworkInfo:\n", .{});
            prettyPrintQVariantMap(value, indentLevel + 1);
        },
        .NetworkServer => |value| {
            std.debug.print("NetworkServer:\n", .{});
            prettyPrintQVariantMap(value, indentLevel + 1);
        },
        .BufferInfo => |value| {
            prettyPrintBufferInfo(value, indentLevel);
        },
        .Message => |value| {
            std.debug.print("Message:\n", .{});

            print_indent_level(indentLevel + 1);
            std.debug.print("MessageID: {d}\n", .{value.MessageID});

            print_indent_level(indentLevel + 1);
            std.debug.print("Timestamp: {d}\n", .{value.Timestamp});

            print_indent_level(indentLevel + 1);
            std.debug.print("Type: {d}\n", .{value.Type});

            print_indent_level(indentLevel + 1);
            std.debug.print("Flags: {d}\n", .{value.Flags});

            print_indent_level(indentLevel + 1);
            std.debug.print("Buffer:\n", .{});
            print_indent_level(indentLevel + 1);
            prettyPrintBufferInfo(value.Buffer, indentLevel + 2);

            print_indent_level(indentLevel + 1);
            std.debug.print("Sender: {s}\n", .{value.Sender});

            print_indent_level(indentLevel + 1);
            std.debug.print("SenderPrefixes: {s}\n", .{value.SenderPrefixes});

            print_indent_level(indentLevel + 1);
            std.debug.print("RealName: {s}\n", .{value.RealName});

            print_indent_level(indentLevel + 1);
            std.debug.print("AvatarUrl: {s}\n", .{value.AvatarUrl});

            print_indent_level(indentLevel + 1);
            std.debug.print("Content: {s}\n", .{value.Content});
        },
        //else => {
        //    std.debug.print("Unknown.\n", .{});
        //},
    }
}

pub fn prettyPrintQVariantMap(qvariantmap: std.StringHashMap(QVariant), indentLevel: u64) void {
    print_indent_level(indentLevel);
    std.debug.print("QVariantMap:\n", .{});
    var qMapIter = qvariantmap.iterator();
    while (qMapIter.next()) |v| {
        print_indent_level(indentLevel + 1);
        std.debug.print("Key: \"{s}\"\n", .{v.key});
        print_indent_level(indentLevel + 1);
        std.debug.print("Value:\n", .{});
        prettyPrintQVariant(v.value, indentLevel + 2);
    }
}

pub fn prettyPrintQVariant(variant: QVariant, indentLevel: u64) void {
    print_indent_level(indentLevel);

    switch (variant) {
        .Byte => |b| {
            std.debug.print("Byte: {d}\n", .{b});
        },
        .Int => |i| {
            std.debug.print("Int: {d}\n", .{i});
        },
        .UInt => |i| {
            std.debug.print("UInt: {d}\n", .{i});
        },
        .QVariantMap => |q| {
            prettyPrintQVariantMap(q, indentLevel + 1);
        },
        .QVariantList => |l| {
            std.debug.print("QVariantList:\n", .{});
            for (l) |varient, i| {
                print_indent_level(indentLevel + 1);
                std.debug.print("Item #{d}\n", .{i});
                prettyPrintQVariant(varient, indentLevel + 2);
            }
        },
        .String => |s| {
            std.debug.print("String: \"{s}\"\n", .{s});
        },
        .QStringList => |l| {
            std.debug.print("QStringList:\n", .{});

            for (l) |str, i| {
                print_indent_level(indentLevel + 1);
                std.debug.print("\"{s}\" \n", .{str});
            }
        },
        .QByteArray => {},
        .QDateTime => |value| {
            std.debug.print("QDateTime:\n", .{});
            print_indent_level(indentLevel + 1);
            std.debug.print("JulianDay: {d}\n", .{value.JulianDay});
            print_indent_level(indentLevel + 1);
            std.debug.print("MillisOfDay: {d}\n", .{value.MillisOfDay});
            print_indent_level(indentLevel + 1);
            std.debug.print("Zone: {d}\n", .{value.Zone});
        },
        .Short => |s| {
            std.debug.print("Short: \"{d}\"\n", .{s});
        },
        .UserType => |value| {
            prettyPrintUserType(value, indentLevel + 1);
        },
    }
}