const zigx = b.dependency("zigx", .{
    .target = target,
    .optimize = optimize,
});
exe.root_module.addImport("zigx", zigx.module("zigx"));

const zigx = @import("zigx");

const result = try zigx.bundle(.{
    .allocator = allocator,
    .include = &.{ "src", "build.zig", "README.md" },
    .exclude = &.{ "*.tmp", ".git", "zig-cache" },
    .output_path = "bundle.zigx",
    .level = .best,
});

std.debug.print("Created: {d} files, {d} bytes\n", .{
    result.file_count,
    result.archive_size,
});

var info = try zigx.getArchiveInfo("bundle.zigx", allocator);
defer info.deinit();

std.debug.print("Format: v{d}, Compression: v{d}\n", .{
    info.format_version,
    info.compression_version,
});
std.debug.print("Files: {d}, Saved: {d:.1}%\n", .{
    info.file_count,
    info.getSavedPercent(),
});

try zigx.unbundle(.{
    .archive_path = "bundle.zigx",
    .output_dir = "extracted",
    .allocator = allocator,
});

const zigx = @import("zigx");

// Custom level using CompressionLevel.custom()
const result = try zigx.bundle(.{
    .allocator = allocator,
    .include = &.{"src"},
    .output_path = "bundle.zigx",
    .level = zigx.CompressionLevel.custom(15),  // zstd level 15
});

// Or use preset configurations
const config = zigx.configWithLevel(12);  // Config with level 12
const config_ldm = zigx.configWithLevelAndLdm(18);  // Level 18 + Long Distance Matching

CompressionLevel.turbo   // Same as .fast
CompressionLevel.maximum // Same as .ultra

// Bundle progress callback
fn onProgress(info: zigx.ProgressInfo, ctx: ?*anyopaque) void {
    _ = ctx;
    switch (info.event) {
        .scanning => std.debug.print("Scanning...\n", .{}),
        .reading_file => {
            if (info.current_file) |file| {
                std.debug.print("\r[{d}/{d}] {s}", .{
                    info.files_processed, info.total_files, file,
                });
            }
        },
        .compressing => {
            std.debug.print("\rCompressing: {d:.1}%", .{info.getPercent()});
        },
        .finalizing => std.debug.print("\nFinalizing...", .{}),
        else => {},
    }
}

// Use in bundle()
const result = try zigx.bundle(.{
    .allocator = allocator,
    .include = &.{"src"},
    .output_path = "bundle.zigx",
    .progress_callback = onProgress,
});

// Extract progress callback
fn onExtractProgress(info: zigx.ExtractProgressInfo, ctx: ?*anyopaque) void {
    _ = ctx;
    switch (info.event) {
        .extracting_file => {
            std.debug.print("\r[{d}/{d}] {s}", .{
                info.files_extracted, info.total_files,
                info.current_file orelse "...",
            });
        },
        .completed => std.debug.print("\nDone!\n", .{}),
        else => {},
    }
}

// Use in unbundle()
try zigx.unbundle(.{
    .archive_path = "bundle.zigx",
    .output_dir = "output",
    .allocator = allocator,
    .progress_callback = onExtractProgress,
});

var builder = zigx.OptionsBuilder.init(allocator);
const opts = builder
    .include(&.{ "src", "build.zig" })
    .exclude(&.{ "*.tmp", "zig-cache" })
    .outputPath("project.zigx")
    .ultra()  // Or .best(), .fast(), .balanced(), .customLevel(15)
    .progress(onProgress, null)
    .build();

const result = try zigx.bundle(opts);

// Quick presets (returns CompressionConfig)
const fast_config = zigx.configFast();        // Level 1
const balanced_config = zigx.configBalanced(); // Level 6
const best_config = zigx.configBest();         // Level 19
const ultra_config = zigx.configUltra();       // Level 22 + LDM

// Custom level presets
const level_config = zigx.configWithLevel(15);          // Any level 1-22
const ldm_config = zigx.configWithLevelAndLdm(18);      // Level + LDM

// Scenario presets
const archival = zigx.configForArchiving();      // Best, preserves metadata
const large_files = zigx.configForLargeFiles();  // Level 6 + LDM + 32MB window
const distribution = zigx.configForDistribution(); // Best, optimized for packages

// ConfigBuilder for custom configs
var builder = zigx.ConfigBuilder.init();
const custom_cfg = builder
    .compressionLevel(.best)
    .adaptive(true)
    .longDistanceMatching(true)
    .build();