const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // Criar arquivo de teste
    const arq = try std.fs.cwd().createFile("temporario.txt", .{});
    arq.close();

    // Deletar o arquivo
    try std.fs.cwd().deleteFile("temporario.txt");
    try stdout.print("Arquivo 'temporario.txt' deletado!\n", .{});
}

const std = @import("std");

fn deletarSeguro(caminho: []const u8) !bool {
    std.fs.cwd().deleteFile(caminho) catch |err| {
        switch (err) {
            error.FileNotFound => return false,
            error.AccessDenied => {
                const stderr = std.io.getStdErr().writer();
                try stderr.print("Sem permissão para deletar '{s}'\n", .{caminho});
                return err;
            },
            else => return err,
        }
    };
    return true;
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // Tentar deletar arquivo que pode não existir
    if (try deletarSeguro("arquivo_que_nao_existe.txt")) {
        try stdout.print("Arquivo deletado\n", .{});
    } else {
        try stdout.print("Arquivo não encontrado (ok)\n", .{});
    }
}

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // Criar e depois deletar diretório vazio
    try std.fs.cwd().makeDir("pasta_vazia");
    try stdout.print("Diretório criado\n", .{});

    try std.fs.cwd().deleteDir("pasta_vazia");
    try stdout.print("Diretório 'pasta_vazia' removido!\n", .{});
}

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // Criar estrutura de teste
    try std.fs.cwd().makePath("projeto_temp/src/modulos");
    const arq1 = try std.fs.cwd().createFile("projeto_temp/README.md", .{});
    arq1.close();
    const arq2 = try std.fs.cwd().createFile("projeto_temp/src/main.zig", .{});
    arq2.close();
    const arq3 = try std.fs.cwd().createFile("projeto_temp/src/modulos/util.zig", .{});
    arq3.close();
    try stdout.print("Estrutura criada\n", .{});

    // Deletar tudo recursivamente
    try std.fs.cwd().deleteTree("projeto_temp");
    try stdout.print("Diretório 'projeto_temp' e todo conteúdo removidos!\n", .{});
}

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // Criar arquivos de teste
    const nomes = [_][]const u8{ "temp1.txt", "temp2.txt", "temp3.txt" };
    for (nomes) |nome| {
        const arq = try std.fs.cwd().createFile(nome, .{});
        arq.close();
    }
    try stdout.print("Arquivos criados\n", .{});

    // Deletar todos
    var deletados: u32 = 0;
    var erros: u32 = 0;
    for (nomes) |nome| {
        std.fs.cwd().deleteFile(nome) catch {
            erros += 1;
            continue;
        };
        deletados += 1;
    }

    try stdout.print("Deletados: {d}, Erros: {d}\n", .{ deletados, erros });
}

const std = @import("std");

fn limparPorExtensao(dir_path: []const u8, extensao: []const u8) !u32 {
    var dir = try std.fs.cwd().openDir(dir_path, .{ .iterate = true });
    defer dir.close();

    var removidos: u32 = 0;
    var iter = dir.iterate();

    while (try iter.next()) |entrada| {
        if (entrada.kind == .file and std.mem.endsWith(u8, entrada.name, extensao)) {
            dir.deleteFile(entrada.name) catch continue;
            removidos += 1;
        }
    }

    return removidos;
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // Criar arquivos de teste
    try std.fs.cwd().makePath("cache");
    const exts = [_][]const u8{ "cache/a.tmp", "cache/b.tmp", "cache/c.log", "cache/d.tmp" };
    for (exts) |nome| {
        const arq = try std.fs.cwd().createFile(nome, .{});
        arq.close();
    }

    const removidos = try limparPorExtensao("cache", ".tmp");
    try stdout.print("Removidos {d} arquivo(s) .tmp\n", .{removidos});

    // Limpar
    try std.fs.cwd().deleteTree("cache");
}