# 查看 Memcached 版本
echo "version" | nc 127.0.0.1 11211
# VERSION 1.6.22 — 支持 Meta 协议

# 启动时启用现代特性
memcached -o modern ...

# 获取值 + flags + CAS + TTL
mg user:1001 f c t
VALUE f0 c123456 t3600
{"name":"Bob"}
END

# 获取值 + 大小 + opaque
mg user:1001 s O12345
VALUE s13 O12345
{"name":"Bob"}
END

# 仅获取元数据，不返回值
mg user:1001 s f c t b
VALUE s13 f0 c123456 t3600 b13
END

# 条件获取（仅当 CAS 匹配时返回值）
mg user:1001 c C123455
END  # CAS 不匹配，不返回值

# 静默模式
mg user:1001 q
# 不存在时无响应

import socket

class MetaGetClient:
    def __init__(self, host='127.0.0.1', port=11211):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((host, port))

    def meta_get(self, key: str, tokens: str = "") -> dict | None:
        """
        mg <key> [tokens...]\r\n

        返回解析后的结果字典，或 None（未命中）
        """
        cmd = f"mg {key} {tokens}".strip() + "\r\n"
        self.sock.sendall(cmd.encode())

        buffer = b""
        while True:
            chunk = self.sock.recv(65536)
            buffer += chunk
            if b"END\r\n" in buffer:
                break

        lines = buffer.split(b"\r\n")
        first_line = lines[0].decode()

        if first_line == "END":
            return None  # 未命中

        # 解析 VALUE 行
        if not first_line.startswith("VALUE"):
            return None

        parts = first_line.split(" ")
        result = {}

        # 解析 token
        for token in parts[1:]:
            if len(token) >= 2:
                token_char = token[0]
                token_value = token[1:]
                result[token_char] = token_value
            elif len(token) == 1:
                result[token] = True

        # 如果有数据体
        if len(lines) >= 3 and lines[1]:
            result['_value'] = lines[1]

        return result

    def close(self):
        self.sock.sendall(b"quit\r\n")
        self.sock.close()

# 使用示例
client = MetaGetClient()

# 获取值 + flags + CAS + TTL
result = client.meta_get("user:1001", "f c t b")
if result:
    print(f"Flags: {result.get('f')}")
    print(f"CAS: {result.get('c')}")
    print(f"TTL: {result.get('t')}")
    print(f"Size: {result.get('b')}")
    print(f"Value: {result.get('_value')}")
else:
    print("未命中")

client.close()

# 基本设置（带 flags 和 TTL）
ms user:1001 13 T3600 F0
{"name":"Bob"}
HD

# 条件设置（仅当 CAS 匹配时）
ms user:1001 15 C123456 T3600 F0
{"name":"Alice"}
HD

# 仅当 key 不存在时设置（类似 add）
ms newkey 5 T60 n
hello
HD

# 静默设置
ms user:1002 10 T300 q
{"id":1002}
# 无响应（成功时）

# 设置并返回 CAS
ms user:1003 10 T300 c
{"id":1003}
HD c789012

class MetaSetClient:
    def __init__(self, host='127.0.0.1', port=11211):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((host, port))

    def meta_set(self, key: str, value: bytes, ttl: int = 0,
                 flags: int = 0, cas: int = 0,
                 add_only: bool = False, noreply: bool = False,
                 return_cas: bool = False) -> dict:
        tokens = []
        if ttl > 0:
            tokens.append(f"T{ttl}")
        if flags > 0:
            tokens.append(f"F{flags}")
        if cas > 0:
            tokens.append(f"C{cas}")
        if add_only:
            tokens.append("n")
        if noreply:
            tokens.append("q")
        if return_cas:
            tokens.append("c")

        cmd = f"ms {key} {len(value)} {' '.join(tokens)}".strip() + "\r\n"
        self.sock.sendall(cmd.encode() + value + b"\r\n")

        if noreply:
            return {'status': 'noreply'}

        buffer = b""
        while True:
            chunk = self.sock.recv(4096)
            buffer += chunk
            if b"\r\n" in buffer:
                break

        line = buffer.decode().strip()
        result = {'raw': line}

        if line.startswith("HD"):
            result['status'] = 'stored'
            # 解析响应 token
            parts = line.split(" ")
            for token in parts[1:]:
                if token.startswith("c"):
                    result['cas'] = int(token[1:])
        elif line == "NS":
            result['status'] = 'not_stored'
        elif line == "EX":
            result['status'] = 'exists'
        elif line == "NF":
            result['status'] = 'not_found'

        return result

    def close(self):
        self.sock.sendall(b"quit\r\n")
        self.sock.close()

# 使用
client = MetaSetClient()

# 基本设置
r = client.meta_set("user:1001", b'{"name":"Bob"}', ttl=3600, flags=0)
print(r)  # {'status': 'stored'}

# 设置并获取 CAS
r = client.meta_set("user:1002", b'{"name":"Alice"}', ttl=3600, return_cas=True)
print(r)  # {'status': 'stored', 'cas': 123456}

# 条件设置（CAS 匹配）
r = client.meta_set("user:1002", b'{"name":"Eve"}', cas=123456, return_cas=True)
print(r)  # {'status': 'stored'} 或 {'status': 'exists'}

client.close()

def meta_delete(sock, key: str, cas: int = 0,
                lazy: bool = False, ttl: int = 0) -> str:
    tokens = []
    if cas > 0:
        tokens.append(f"C{cas}")
    if lazy:
        tokens.append("I")
        if ttl > 0:
            tokens.append(f"T{ttl}")

    cmd = f"md {key} {' '.join(tokens)}".strip() + "\r\n"
    sock.sendall(cmd.encode())

    buffer = b""
    while True:
        chunk = sock.recv(4096)
        buffer += chunk
        if b"\r\n" in buffer:
            break

    return buffer.decode().strip()

# 标记为无效（不立即从哈希表中删除）
md user:1001 I T60
HD

# 此后 get 操作返回未命中
mg user:1001 v
END

# 60 秒后 item 被自动清理

def meta_arithmetic(sock, key: str, delta: int = 1,
                    initial: int = 0, ttl: int = 0) -> int | None:
    tokens = [f"D{delta}"]
    if initial is not None:
        tokens.append(f"N{initial}")
    if ttl > 0:
        tokens.append(f"T{ttl}")

    cmd = f"ma {key} {' '.join(tokens)}".strip() + "\r\n"
    sock.sendall(cmd.encode())

    buffer = b""
    while True:
        chunk = sock.recv(4096)
        buffer += chunk
        if b"\r\n" in buffer:
            break

    lines = buffer.decode().strip().split("\r\n")
    if lines[0].startswith("VA"):
        return int(lines[1])
    return None

# 递增 1（不存在时初始化为 100）
ma counter D1 N100 T3600
VA 3
100

# 递增 5
ma counter D5
VA 3
105

# 递减 10
ma counter D-10
VA 2
95

# 读取用户数据并刷新 TTL 为 3600 秒
mg user:1001 f T3600
VALUE f0
{"name":"Bob"}
END

get user:1001
VALUE user:1001 0 13
{"name":"Bob"}
END

# 然后 touch（需要额外往返）
touch user:1001 3600
TOUCHED

def safe_update(sock, key: str, new_value: bytes, max_retries: int = 5):
    """使用 Meta 协议的原子 CAS 更新"""
    for attempt in range(max_retries):
        # 1. 获取当前值和 CAS
        sock.sendall(f"mg {key} c f\r\n".encode())
        resp = _read_response(sock)

        if resp is None:
            # key 不存在，直接写入
            sock.sendall(f"ms {key} {len(new_value)} n\r\n".encode()
                        + new_value + b"\r\n")
            result = _read_response(sock)
            if result == "HD":
                return True
            continue

        cas = resp.get('c')
        flags = resp.get('f', '0')

        # 2. CAS 写入
        sock.sendall(
            f"ms {key} {len(new_value)} C{cas} F{flags}\r\n".encode()
            + new_value + b"\r\n"
        )
        result = _read_response(sock)
        if result == "HD":
            return True  # 成功
        # EX = CAS 冲突，重试

    return False

import uuid
import time

class MetaDistributedLock:
    def __init__(self, sock, lock_key: str, ttl: int = 30):
        self.sock = sock
        self.lock_key = f"lock:{lock_key}"
        self.token = str(uuid.uuid4()).encode()
        self.ttl = ttl
        self.cas = 0

    def acquire(self, timeout: int = 10) -> bool:
        deadline = time.time() + timeout
        while time.time() < deadline:
            # 尝试 add
            cmd = f"ms {self.lock_key} {len(self.token)} n T{self.ttl} c\r\n"
            self.sock.sendall(cmd.encode() + self.token + b"\r\n")
            resp = self._read_resp()

            if resp and resp.startswith("HD"):
                # 解析返回的 CAS
                parts = resp.split(" ")
                for part in parts:
                    if part.startswith("c"):
                        self.cas = int(part[1:])
                return True
            time.sleep(0.1)
        return False

    def release(self) -> bool:
        if self.cas == 0:
            return False
        # 使用 CAS 删除（只有持有正确 CAS 的客户端才能删除）
        cmd = f"md {self.lock_key} C{self.cas}\r\n"
        self.sock.sendall(cmd.encode())
        resp = self._read_resp()
        return resp == "HD"

    def _read_resp(self) -> str:
        buffer = b""
        while True:
            chunk = self.sock.recv(4096)
            buffer += chunk
            if b"\r\n" in buffer:
                break
        return buffer.decode().strip()