import socket

def read_resp_error(sock: socket.socket) -> str:
    """从 socket 读取一个 RESP Error"""
    buf = b""
    while True:
        byte = sock.recv(1)
        if byte == b"\r":
            sock.recv(1)  # 跳过 \n
            break
        buf += byte
    return buf.decode("utf-8")

# 连接 Redis 并触发错误
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("127.0.0.1", 6379))

# 发送一个不存在的命令
s.sendall(b"*1\r\n$7\r\nINVALID\r\n")
resp = s.recv(1024)
print(f"Raw response: {resp}")
# Raw response: b"-ERR unknown command 'INVALID'\r\n"
s.close()

// Go 语言解析 Integer 示例
func parseInteger(line []byte) (int64, error) {
    // line 不包含 \r\n，格式如 ":123"
    if len(line) < 2 || line[0] != ':' {
        return 0, fmt.Errorf("invalid integer: %s", line)
    }
    return strconv.ParseInt(string(line[1:]), 10, 64)
}

class RESPReader:
    def __init__(self, data: bytes):
        self.data = data
        self.pos = 0

    def read_line(self) -> bytes:
        """读取一行（到 \r\n 为止），不包含 \r\n"""
        end = self.data.index(b"\r\n", self.pos)
        line = self.data[self.pos:end]
        self.pos = end + 2
        return line

    def read_bulk_string(self) -> bytes | None:
        """解析一个 Bulk String"""
        line = self.read_line()
        assert line.startswith(b"$"), f"Expected $, got {line}"

        length = int(line[1:])
        if length == -1:
            return None  # NULL

        # 读取 length 个字节
        value = self.data[self.pos:self.pos + length]
        self.pos += length + 2  # +2 跳过 \r\n
        return value

import socket
from typing import Any

class RESP2Parser:
    def __init__(self, sock: socket.socket):
        self.sock = sock
        self.buffer = b""

    def _read_bytes(self, n: int) -> bytes:
        """从 socket 读取 n 个字节"""
        while len(self.buffer) < n:
            chunk = self.sock.recv(4096)
            if not chunk:
                raise ConnectionError("Connection closed")
            self.buffer += chunk
        result = self.buffer[:n]
        self.buffer = self.buffer[n:]
        return result

    def _read_line(self) -> bytes:
        """读取一行（到 \r\n 为止）"""
        while b"\r\n" not in self.buffer:
            chunk = self.sock.recv(4096)
            if not chunk:
                raise ConnectionError("Connection closed")
            self.buffer += chunk
        pos = self.buffer.index(b"\r\n")
        line = self.buffer[:pos]
        self.buffer = self.buffer[pos + 2:]
        return line

    def parse(self) -> Any:
        """解析一个 RESP2 值"""
        line = self._read_line()
        type_byte = line[0:1]

        if type_byte == b"+":
            # Simple String
            return line[1:].decode("utf-8")

        elif type_byte == b"-":
            # Error
            raise RedisError(line[1:].decode("utf-8"))

        elif type_byte == b":":
            # Integer
            return int(line[1:])

        elif type_byte == b"$":
            # Bulk String
            length = int(line[1:])
            if length == -1:
                return None
            data = self._read_bytes(length + 2)  # +2 for \r\n
            return data[:length].decode("utf-8")

        elif type_byte == b"*":
            # Array
            count = int(line[1:])
            if count == -1:
                return None
            return [self.parse() for _ in range(count)]

        else:
            raise ValueError(f"Unknown type: {type_byte}")


class RedisError(Exception):
    pass

import socket

def encode_command(*args: str) -> bytes:
    """将命令编码为 RESP2 格式"""
    parts = [f"*{len(args)}\r\n"]
    for arg in args:
        arg_bytes = arg.encode("utf-8")
        parts.append(f"${len(arg_bytes)}\r\n")
        parts.append(arg.decode("utf-8") if isinstance(arg, bytes) else arg)
        parts.append("\r\n")
    return "".join(parts).encode("utf-8")

def encode_command_binary(*args: bytes) -> bytes:
    """将命令编码为 RESP2 格式（二进制安全版本）"""
    header = f"*{len(args)}\r\n".encode()
    body = b""
    for arg in args:
        body += f"${len(arg)}\r\n".encode() + arg + b"\r\n"
    return header + body

# 使用示例
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("127.0.0.1", 6379))

# SET
s.sendall(encode_command_binary(b"SET", b"greeting", b"hello world"))
print(s.recv(1024))  # b'+OK\r\n'

# GET
s.sendall(encode_command_binary(b"GET", b"greeting"))
print(s.recv(1024))  # b'$11\r\nhello world\r\n'

# INCR
s.sendall(encode_command_binary(b"INCR", b"counter"))
print(s.recv(1024))  # b':1\r\n'

s.close()