Como Conectar ao Redis com Zig: Cache e Pub/Sub

const std = @import("std");
const net = std.net;

pub const RedisConnection = struct {
    stream: net.Stream,

    pub fn connect(host: []const u8, port: u16) !RedisConnection {
        const address = try net.Address.resolveIp(host, port);
        const stream = try net.tcpConnectToAddress(address);
        return RedisConnection{ .stream = stream };
    }

    pub fn connectDefault() !RedisConnection {
        return connect("127.0.0.1", 6379);
    }

    pub fn close(self: *RedisConnection) void {
        self.stream.close();
    }
};

pub fn main() !void {
    var conn = try RedisConnection.connectDefault();
    defer conn.close();

    std.debug.print("Conectado ao Redis com sucesso!\n", .{});
}

*3\r\n$3\r\nSET\r\n$5\r\nchave\r\n$5\r\nvalor\r\n

const std = @import("std");
const net = std.net;

fn sendRawCommand(stream: net.Stream, command: []const u8) !void {
    _ = try stream.write(command);
}

fn readResponse(stream: net.Stream, buffer: []u8) ![]const u8 {
    const bytes_read = try stream.read(buffer);
    if (bytes_read == 0) return error.ConnectionClosed;
    return buffer[0..bytes_read];
}

pub fn main() !void {
    const address = try net.Address.resolveIp("127.0.0.1", 6379);
    const stream = try net.tcpConnectToAddress(address);
    defer stream.close();

    // Enviando PING ao Redis
    const ping_cmd = "*1\r\n$4\r\nPING\r\n";
    _ = try stream.write(ping_cmd);

    var buffer: [4096]u8 = undefined;
    const response = try readResponse(stream, &buffer);
    std.debug.print("Resposta do Redis: {s}\n", .{response});
    // Saída esperada: +PONG
}

const std = @import("std");
const Allocator = std.mem.Allocator;

pub const RespEncoder = struct {
    allocator: Allocator,

    pub fn init(allocator: Allocator) RespEncoder {
        return RespEncoder{ .allocator = allocator };
    }

    /// Codifica uma lista de argumentos no formato RESP array.
    /// Exemplo: encodeCommand(&.{"SET", "chave", "valor"})
    /// Produz: *3\r\n$3\r\nSET\r\n$5\r\nchave\r\n$5\r\nvalor\r\n
    pub fn encodeCommand(self: *const RespEncoder, args: []const []const u8) ![]u8 {
        var list = std.ArrayList(u8).init(self.allocator);
        errdefer list.deinit();

        // Cabeçalho do array: *N\r\n
        try list.writer().print("*{d}\r\n", .{args.len});

        // Cada argumento como bulk string: $L\r\nDADOS\r\n
        for (args) |arg| {
            try list.writer().print("${d}\r\n", .{arg.len});
            try list.appendSlice(arg);
            try list.appendSlice("\r\n");
        }

        return list.toOwnedSlice();
    }
};

pub const RespValue = union(enum) {
    simple_string: []const u8,
    error_msg: []const u8,
    integer: i64,
    bulk_string: ?[]const u8, // null para bulk string nil ($-1)
    array: ?[]RespValue, // null para array nil (*-1)
};

pub const RespParser = struct {
    data: []const u8,
    pos: usize,
    allocator: Allocator,

    pub fn init(allocator: Allocator, data: []const u8) RespParser {
        return RespParser{
            .data = data,
            .pos = 0,
            .allocator = allocator,
        };
    }

    fn readLine(self: *RespParser) ![]const u8 {
        const start = self.pos;
        while (self.pos < self.data.len - 1) {
            if (self.data[self.pos] == '\r' and self.data[self.pos + 1] == '\n') {
                const line = self.data[start..self.pos];
                self.pos += 2; // pula \r\n
                return line;
            }
            self.pos += 1;
        }
        return error.IncompleteData;
    }

    fn readBytes(self: *RespParser, count: usize) ![]const u8 {
        if (self.pos + count + 2 > self.data.len) return error.IncompleteData;
        const slice = self.data[self.pos .. self.pos + count];
        self.pos += count + 2; // pula os dados + \r\n
        return slice;
    }

    pub fn parse(self: *RespParser) !RespValue {
        if (self.pos >= self.data.len) return error.IncompleteData;

        const type_byte = self.data[self.pos];
        self.pos += 1;

        return switch (type_byte) {
            '+' => {
                const line = try self.readLine();
                return RespValue{ .simple_string = line };
            },
            '-' => {
                const line = try self.readLine();
                return RespValue{ .error_msg = line };
            },
            ':' => {
                const line = try self.readLine();
                const value = try std.fmt.parseInt(i64, line, 10);
                return RespValue{ .integer = value };
            },
            '$' => {
                const line = try self.readLine();
                const length = try std.fmt.parseInt(i64, line, 10);
                if (length == -1) {
                    return RespValue{ .bulk_string = null };
                }
                const content = try self.readBytes(@intCast(length));
                return RespValue{ .bulk_string = content };
            },
            '*' => {
                const line = try self.readLine();
                const count = try std.fmt.parseInt(i64, line, 10);
                if (count == -1) {
                    return RespValue{ .array = null };
                }
                const arr_len: usize = @intCast(count);
                const items = try self.allocator.alloc(RespValue, arr_len);
                for (0..arr_len) |i| {
                    items[i] = try self.parse();
                }
                return RespValue{ .array = items };
            },
            else => return error.UnknownRespType,
        };
    }
};

pub const RedisClient = struct {
    stream: std.net.Stream,
    allocator: Allocator,
    read_buffer: [8192]u8,

    pub fn init(allocator: Allocator, host: []const u8, port: u16) !RedisClient {
        const address = try std.net.Address.resolveIp(host, port);
        const stream = try std.net.tcpConnectToAddress(address);
        return RedisClient{
            .stream = stream,
            .allocator = allocator,
            .read_buffer = undefined,
        };
    }

    pub fn deinit(self: *RedisClient) void {
        self.stream.close();
    }

    /// Envia um comando RESP e retorna a resposta parseada.
    pub fn sendCommand(self: *RedisClient, args: []const []const u8) !RespValue {
        const encoder = RespEncoder.init(self.allocator);
        const encoded = try encoder.encodeCommand(args);
        defer self.allocator.free(encoded);

        _ = try self.stream.write(encoded);

        const bytes_read = try self.stream.read(&self.read_buffer);
        if (bytes_read == 0) return error.ConnectionClosed;

        var parser = RespParser.init(self.allocator, self.read_buffer[0..bytes_read]);
        return parser.parse();
    }
};

pub fn set(self: *RedisClient, key: []const u8, value: []const u8) !void {
    const args = &[_][]const u8{ "SET", key, value };
    const result = try self.sendCommand(args);
    switch (result) {
        .simple_string => |s| {
            if (!std.mem.eql(u8, s, "OK")) {
                return error.UnexpectedResponse;
            }
        },
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

pub fn get(self: *RedisClient, key: []const u8) !?[]const u8 {
    const args = &[_][]const u8{ "GET", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .bulk_string => |maybe_value| {
            return maybe_value; // retorna null se a chave não existir
        },
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

pub fn del(self: *RedisClient, key: []const u8) !i64 {
    const args = &[_][]const u8{ "DEL", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |count| return count,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Remove múltiplas chaves de uma vez.
pub fn delMultiple(self: *RedisClient, keys: []const []const u8) !i64 {
    var args = std.ArrayList([]const u8).init(self.allocator);
    defer args.deinit();

    try args.append("DEL");
    for (keys) |key| {
        try args.append(key);
    }

    const result = try self.sendCommand(args.items);
    switch (result) {
        .integer => |count| return count,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

pub fn exists(self: *RedisClient, key: []const u8) !bool {
    const args = &[_][]const u8{ "EXISTS", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |count| return count > 0,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var client = try RedisClient.init(allocator, "127.0.0.1", 6379);
    defer client.deinit();

    // SET: armazena um valor
    try client.set("usuario:1:nome", "Maria Silva");
    std.debug.print("SET usuario:1:nome = 'Maria Silva'\n", .{});

    // GET: recupera o valor
    if (try client.get("usuario:1:nome")) |nome| {
        std.debug.print("GET usuario:1:nome = '{s}'\n", .{nome});
    } else {
        std.debug.print("Chave não encontrada\n", .{});
    }

    // EXISTS: verifica existência
    const existe = try client.exists("usuario:1:nome");
    std.debug.print("EXISTS usuario:1:nome = {}\n", .{existe});

    // DEL: remove a chave
    const removidas = try client.del("usuario:1:nome");
    std.debug.print("DEL usuario:1:nome = {d} chave(s) removida(s)\n", .{removidas});

    // GET após remoção: deve retornar null
    if (try client.get("usuario:1:nome")) |_| {
        std.debug.print("Chave ainda existe (inesperado)\n", .{});
    } else {
        std.debug.print("Chave removida com sucesso\n", .{});
    }
}

/// Define uma chave com valor e tempo de expiração em segundos.
pub fn setex(self: *RedisClient, key: []const u8, seconds: u32, value: []const u8) !void {
    var seconds_buf: [20]u8 = undefined;
    const seconds_str = std.fmt.bufPrint(&seconds_buf, "{d}", .{seconds}) catch unreachable;

    const args = &[_][]const u8{ "SETEX", key, seconds_str, value };
    const result = try self.sendCommand(args);
    switch (result) {
        .simple_string => |s| {
            if (!std.mem.eql(u8, s, "OK")) {
                return error.UnexpectedResponse;
            }
        },
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Define tempo de expiração em segundos para uma chave existente.
/// Retorna true se o timeout foi definido, false se a chave não existe.
pub fn expire(self: *RedisClient, key: []const u8, seconds: u32) !bool {
    var seconds_buf: [20]u8 = undefined;
    const seconds_str = std.fmt.bufPrint(&seconds_buf, "{d}", .{seconds}) catch unreachable;

    const args = &[_][]const u8{ "EXPIRE", key, seconds_str };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |val| return val == 1,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Retorna o tempo restante de vida da chave em segundos.
/// Retorna -1 se a chave existe mas não tem expiração.
/// Retorna -2 se a chave não existe.
pub fn ttl(self: *RedisClient, key: []const u8) !i64 {
    const args = &[_][]const u8{ "TTL", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |val| return val,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Remove a expiração de uma chave, tornando-a permanente.
/// Retorna true se a expiração foi removida.
pub fn persist(self: *RedisClient, key: []const u8) !bool {
    const args = &[_][]const u8{ "PERSIST", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |val| return val == 1,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var client = try RedisClient.init(allocator, "127.0.0.1", 6379);
    defer client.deinit();

    // Cria uma sessão com expiração de 30 minutos (1800 segundos)
    try client.setex("sessao:abc123", 1800, "usuario:42");
    std.debug.print("Sessão criada com TTL de 1800 segundos\n", .{});

    // Verifica o TTL restante
    const tempo_restante = try client.ttl("sessao:abc123");
    std.debug.print("TTL restante: {d} segundos\n", .{tempo_restante});

    // Renova a sessão (redefine o TTL)
    const renovado = try client.expire("sessao:abc123", 3600);
    std.debug.print("Sessão renovada para 1 hora: {}\n", .{renovado});

    // Token temporário com SET e EXPIRE separados
    try client.set("token:reset:xyz", "usuario:42");
    _ = try client.expire("token:reset:xyz", 300); // 5 minutos

    const ttl_token = try client.ttl("token:reset:xyz");
    std.debug.print("Token de reset expira em: {d} segundos\n", .{ttl_token});

    // Remove expiração (torna permanente)
    _ = try client.persist("sessao:abc123");
    const ttl_sessao = try client.ttl("sessao:abc123");
    std.debug.print("TTL após persist: {d} (deve ser -1)\n", .{ttl_sessao});
}

/// Insere um ou mais elementos no início (esquerda) da lista.
/// Retorna o comprimento da lista após a inserção.
pub fn lpush(self: *RedisClient, key: []const u8, value: []const u8) !i64 {
    const args = &[_][]const u8{ "LPUSH", key, value };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |len| return len,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Insere um ou mais elementos no final (direita) da lista.
/// Retorna o comprimento da lista após a inserção.
pub fn rpush(self: *RedisClient, key: []const u8, value: []const u8) !i64 {
    const args = &[_][]const u8{ "RPUSH", key, value };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |len| return len,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Remove e retorna o primeiro elemento da lista (esquerda).
pub fn lpop(self: *RedisClient, key: []const u8) !?[]const u8 {
    const args = &[_][]const u8{ "LPOP", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .bulk_string => |maybe_value| return maybe_value,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Remove e retorna o último elemento da lista (direita).
pub fn rpop(self: *RedisClient, key: []const u8) !?[]const u8 {
    const args = &[_][]const u8{ "RPOP", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .bulk_string => |maybe_value| return maybe_value,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Retorna os elementos da lista no intervalo [start, stop].
/// Use start=0 e stop=-1 para obter todos os elementos.
pub fn lrange(
    self: *RedisClient,
    key: []const u8,
    start: i64,
    stop: i64,
) !?[]RespValue {
    var start_buf: [20]u8 = undefined;
    var stop_buf: [20]u8 = undefined;
    const start_str = std.fmt.bufPrint(&start_buf, "{d}", .{start}) catch unreachable;
    const stop_str = std.fmt.bufPrint(&stop_buf, "{d}", .{stop}) catch unreachable;

    const args = &[_][]const u8{ "LRANGE", key, start_str, stop_str };
    const result = try self.sendCommand(args);
    switch (result) {
        .array => |maybe_items| return maybe_items,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// LLEN: retorna o comprimento da lista.
pub fn llen(self: *RedisClient, key: []const u8) !i64 {
    const args = &[_][]const u8{ "LLEN", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |len| return len,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var client = try RedisClient.init(allocator, "127.0.0.1", 6379);
    defer client.deinit();

    const fila = "fila:emails";

    // Adiciona tarefas na fila (RPUSH para inserir no final)
    _ = try client.rpush(fila, "enviar:boas-vindas:usuario@email.com");
    _ = try client.rpush(fila, "enviar:confirmacao:admin@email.com");
    _ = try client.rpush(fila, "enviar:relatorio:gerente@email.com");
    std.debug.print("3 tarefas adicionadas à fila\n", .{});

    // Verifica o tamanho da fila
    const tamanho = try client.llen(fila);
    std.debug.print("Tamanho da fila: {d}\n", .{tamanho});

    // Lista todas as tarefas pendentes
    if (try client.lrange(fila, 0, -1)) |items| {
        std.debug.print("Tarefas pendentes:\n", .{});
        for (items, 0..) |item, i| {
            switch (item) {
                .bulk_string => |maybe_val| {
                    if (maybe_val) |val| {
                        std.debug.print("  [{d}] {s}\n", .{ i, val });
                    }
                },
                else => {},
            }
        }
    }

    // Processa tarefas uma a uma (LPOP para consumir do início)
    std.debug.print("\nProcessando tarefas:\n", .{});
    while (try client.lpop(fila)) |tarefa| {
        std.debug.print("  Processando: {s}\n", .{tarefa});
        // Aqui você processaria cada tarefa de verdade
    }

    std.debug.print("Fila vazia, todas as tarefas processadas\n", .{});
}

/// Define um campo em um hash. Retorna 1 se o campo foi criado,
/// 0 se o campo já existia e foi atualizado.
pub fn hset(
    self: *RedisClient,
    key: []const u8,
    field: []const u8,
    value: []const u8,
) !i64 {
    const args = &[_][]const u8{ "HSET", key, field, value };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |val| return val,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Define múltiplos campos de um hash de uma vez.
pub fn hsetMultiple(
    self: *RedisClient,
    key: []const u8,
    fields_and_values: []const [2][]const u8,
) !void {
    var args = std.ArrayList([]const u8).init(self.allocator);
    defer args.deinit();

    try args.append("HSET");
    try args.append(key);
    for (fields_and_values) |pair| {
        try args.append(pair[0]); // campo
        try args.append(pair[1]); // valor
    }

    const result = try self.sendCommand(args.items);
    switch (result) {
        .integer => {},
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Retorna o valor de um campo específico do hash.
/// Retorna null se a chave ou o campo não existirem.
pub fn hget(
    self: *RedisClient,
    key: []const u8,
    field: []const u8,
) !?[]const u8 {
    const args = &[_][]const u8{ "HGET", key, field };
    const result = try self.sendCommand(args);
    switch (result) {
        .bulk_string => |maybe_value| return maybe_value,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// Retorna todos os campos e valores do hash como array alternado
/// [campo1, valor1, campo2, valor2, ...].
pub fn hgetall(self: *RedisClient, key: []const u8) !?[]RespValue {
    const args = &[_][]const u8{ "HGETALL", key };
    const result = try self.sendCommand(args);
    switch (result) {
        .array => |maybe_items| return maybe_items,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// HDEL: remove um campo do hash.
pub fn hdel(
    self: *RedisClient,
    key: []const u8,
    field: []const u8,
) !i64 {
    const args = &[_][]const u8{ "HDEL", key, field };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |val| return val,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

/// HEXISTS: verifica se um campo existe no hash.
pub fn hexists(
    self: *RedisClient,
    key: []const u8,
    field: []const u8,
) !bool {
    const args = &[_][]const u8{ "HEXISTS", key, field };
    const result = try self.sendCommand(args);
    switch (result) {
        .integer => |val| return val == 1,
        .error_msg => return error.RedisError,
        else => return error.UnexpectedResponse,
    }
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var client = try RedisClient.init(allocator, "127.0.0.1", 6379);
    defer client.deinit();

    const chave_perfil = "usuario:42";

    // Cria o perfil com múltiplos campos de uma vez
    const campos = [_][2][]const u8{
        .{ "nome", "Maria Silva" },
        .{ "email", "maria@exemplo.com" },
        .{ "cidade", "São Paulo" },
        .{ "profissao", "Engenheira de Software" },
        .{ "linguagem_favorita", "Zig" },
    };
    try client.hsetMultiple(chave_perfil, &campos);
    std.debug.print("Perfil criado com {d} campos\n", .{campos.len});

    // Recupera um campo específico
    if (try client.hget(chave_perfil, "nome")) |nome| {
        std.debug.print("Nome: {s}\n", .{nome});
    }

    // Atualiza um campo existente
    _ = try client.hset(chave_perfil, "cidade", "Rio de Janeiro");
    std.debug.print("Cidade atualizada\n", .{});

    // Verifica se um campo existe
    const tem_telefone = try client.hexists(chave_perfil, "telefone");
    std.debug.print("Tem telefone? {}\n", .{tem_telefone});

    // Lista todos os campos e valores
    if (try client.hgetall(chave_perfil)) |items| {
        std.debug.print("\nPerfil completo:\n", .{});
        var i: usize = 0;
        while (i + 1 < items.len) : (i += 2) {
            const campo = switch (items[i]) {
                .bulk_string => |v| v orelse "(nil)",
                else => "(erro)",
            };
            const valor = switch (items[i + 1]) {
                .bulk_string => |v| v orelse "(nil)",
                else => "(erro)",
            };
            std.debug.print("  {s}: {s}\n", .{ campo, valor });
        }
    }

    // Remove um campo
    _ = try client.hdel(chave_perfil, "profissao");
    std.debug.print("\nCampo 'profissao' removido\n", .{});
}