# 静态表实现
STATIC_TABLE = {
    1: (":authority", ""),
    2: (":method", "GET"),
    3: (":method", "POST"),
    4: (":path", "/"),
    5: (":path", "/index.html"),
    6: (":scheme", "http"),
    7: (":scheme", "https"),
    8: (":status", "200"),
    9: (":status", "204"),
    10: (":status", "206"),
    11: (":status", "304"),
    12: (":status", "400"),
    13: (":status", "404"),
    14: (":status", "500"),
    15: ("accept-charset", ""),
    16: ("accept-encoding", "gzip, deflate"),
    # ... 完整 61 个条目
}

def find_in_static_table(name: str, value: str = "") -> int:
    """在静态表中查找匹配的条目"""
    for idx, (n, v) in STATIC_TABLE.items():
        if n == name and (v == value or value == ""):
            return idx
    return -1

# 示例查询
idx = find_in_static_table(":method", "GET")
print(f":method:GET 在静态表索引 {idx}")  # 输出: 2

idx = find_in_static_table(":status", "200")
print(f":status:200 在静态表索引 {idx}")  # 输出: 8

from collections import OrderedDict
from typing import Optional, Tuple

class DynamicTable:
    def __init__(self, max_size: int = 4096):
        self.max_size = max_size
        self.current_size = 0
        self.entries: OrderedDict[int, Tuple[str, str]] = OrderedDict()
        self.next_index = 62  # 静态表最大索引 + 1
    
    def entry_size(self, name: str, value: str) -> int:
        """计算条目占用的字节数"""
        return len(name.encode()) + len(value.encode()) + 32  # 32 字节开销
    
    def add(self, name: str, value: str):
        """添加新条目"""
        entry_size = self.entry_size(name, value)
        
        # 如果单个条目超过最大大小，清空表
        if entry_size > self.max_size:
            self.entries.clear()
            self.current_size = 0
            return
        
        # 驱逐旧条目以腾出空间
        while self.current_size + entry_size > self.max_size:
            self._evict()
        
        # 插入新条目（头部插入，最近使用的在前）
        self.entries[self.next_index] = (name, value)
        self.next_index += 1
        self.current_size += entry_size
    
    def _evict(self):
        """驱逐最旧的条目"""
        if self.entries:
            _, (name, value) = self.entries.popitem(last=False)
            self.current_size -= self.entry_size(name, value)
    
    def find(self, name: str, value: str = "") -> Optional[int]:
        """查找匹配的条目"""
        for idx, (n, v) in self.entries.items():
            if n == name and (v == value or value == ""):
                return idx
        return None
    
    def resize(self, new_max_size: int):
        """调整表大小"""
        while self.current_size > new_max_size:
            self._evict()
        self.max_size = new_max_size

# 使用示例
table = DynamicTable(max_size=256)
table.add(":path", "/api/users")
table.add("authorization", "Bearer abc123")

idx = table.find("authorization", "Bearer abc123")
print(f"找到 authorization 在索引 {idx}")  # 62 或 63

table.resize(128)  # 缩小表大小，驱逐旧条目

# HPACK Huffman 编码简化示例
# 注意：实际 HPACK 使用 RFC 7541 定义的 Huffman 表

class HuffmanEncoder:
    """简化的 Huffman 编码器（演示用）"""
    
    # 简化的 Huffman 表（仅演示部分字符）
    HUFFMAN_TABLE = {
        'a': '000',    # 3 bits
        'e': '001',    # 3 bits
        'i': '010',    # 3 bits
        'o': '011',    # 3 bits
        't': '100',    # 3 bits
        'n': '101',    # 3 bits
        's': '1100',   # 4 bits
        'r': '1101',   # 4 bits
        ' ': '1110',   # 4 bits (空格)
        'h': '11110',  # 5 bits
        'l': '111110', # 6 bits
        'd': '111111', # 6 bits
    }
    
    # 反向表
    REVERSE_TABLE = {v: k for k, v in HUFFMAN_TABLE.items()}
    
    @classmethod
    def encode(cls, text: str) -> str:
        result = []
        for ch in text:
            if ch in cls.HUFFMAN_TABLE:
                result.append(cls.HUFFMAN_TABLE[ch])
            else:
                # 不在表中的字符使用 8 位原始编码
                result.append(format(ord(ch), '08b'))
        return ''.join(result)
    
    @classmethod
    def decode(cls, bits: str) -> str:
        result = []
        i = 0
        while i < len(bits):
            for length in range(3, 9):  # 尝试不同长度
                chunk = bits[i:i+length]
                if chunk in cls.REVERSE_TABLE:
                    result.append(cls.REVERSE_TABLE[chunk])
                    i += length
                    break
            else:
                # 8 位原始字符
                result.append(chr(int(bits[i:i+8], 2)))
                i += 8
        return ''.join(result)

# 示例
text = "the cat"
encoded = HuffmanEncoder.encode(text)
decoded = HuffmanEncoder.decode(encoded)

print(f"原文: {text}")
print(f"编码: {encoded}")
print(f"原文比特数: {len(text) * 8}")
print(f"压缩后比特数: {len(encoded)}")
print(f"压缩率: {len(encoded) / (len(text) * 8) * 100:.1f}%")
print(f"解码: {decoded}")

from typing import List

class HPACKEncoder:
    def __init__(self, dynamic_table_size: int = 4096):
        self.dynamic_table = DynamicTable(dynamic_table_size)
    
    def encode_header(self, name: str, value: str) -> bytes:
        """编码单个头部字段"""
        # 1. 检查静态表
        static_idx = find_in_static_table(name, value)
        if static_idx > 0:
            # 完整匹配静态表 → 索引头部字段
            return self._encode_indexed(static_idx)
        
        # 2. 检查动态表
        dynamic_idx = self.dynamic_table.find(name, value)
        if dynamic_idx:
            return self._encode_indexed(dynamic_idx)
        
        # 3. 检查名称是否在表中（仅名称匹配）
        name_idx = self._find_name(name)
        
        # 4. 编码为字面量
        encoded = self._encode_literal(name, value, name_idx)
        
        # 5. 添加到动态表
        self.dynamic_table.add(name, value)
        
        return encoded
    
    def _encode_indexed(self, index: int) -> bytes:
        """编码索引头部字段"""
        if index < 128:
            return bytes([0x80 | index])
        else:
            # 多字节编码（简化处理）
            return bytes([0x80 | (index & 0x7F)])
    
    def _encode_literal(self, name: str, value: str, name_idx: int = -1) -> bytes:
        """编码字面量头部字段"""
        result = bytearray()
        
        if name_idx > 0:
            # 使用索引的名称
            result.append(0x40 | (name_idx & 0x3F))
        else:
            # 名称也需要编码
            result.append(0x00)
            result.extend(self._encode_string(name))
        
        result.extend(self._encode_string(value))
        return bytes(result)
    
    def _encode_string(self, s: str) -> bytes:
        """编码字符串（带长度前缀）"""
        encoded = s.encode('utf-8')
        length = len(encoded)
        
        if length < 128:
            return bytes([length]) + encoded
        else:
            # 多字节长度编码
            return bytes([0x80 | (length & 0x7F)]) + encoded
    
    def _find_name(self, name: str) -> int:
        """仅在表中查找名称（不匹配值）"""
        for idx, (n, _) in STATIC_TABLE.items():
            if n == name:
                return idx
        return self.dynamic_table.find(name) or -1

# 使用示例
encoder = HPACKEncoder()

# 编码一组请求头部
headers = [
    (":method", "GET"),
    (":path", "/api/users"),
    (":scheme", "https"),
    (":authority", "api.example.com"),
    ("accept", "application/json"),
    ("authorization", "Bearer mytoken123"),
]

total_bytes = 0
for name, value in headers:
    encoded = encoder.encode_header(name, value)
    total_bytes += len(encoded)
    print(f"{name}: {value}")
    print(f"  编码: {encoded.hex()}")
    print(f"  大小: {len(encoded)} 字节")

print(f"\n总计: {total_bytes} 字节")
print(f"文本格式估算: {sum(len(n)+len(v) for n,v in headers)} 字节")

# 敏感头部标记
SENSITIVE_HEADERS = {
    "authorization",
    "cookie",
    "set-cookie",
    "proxy-authorization",
}

class SecureHPACKEncoder(HPACKEncoder):
    def encode_header(self, name: str, value: str) -> bytes:
        if name.lower() in SENSITIVE_HEADERS:
            # never-indexed：不添加到动态表
            return self._encode_never_indexed(name, value)
        return super().encode_header(name, value)
    
    def _encode_never_indexed(self, name: str, value: str) -> bytes:
        """never-indexed 编码"""
        result = bytearray()
        result.append(0x10)  # never-indexed 标志
        result.extend(self._encode_string(name))
        result.extend(self._encode_string(value))
        return bytes(result)

// 禁用 HPACK 动态表（最高安全级别）
package main

import (
	"net/http"
)

func main() {
	server := &http.Server{
		Addr: ":8443",
		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.Write([]byte("Hello"))
		}),
		// 通过自定义 HTTP/2 Transport 设置动态表大小为 0
	}
	
	// 方法 1：客户端禁用动态表
	// transport := &http2.Transport{
	//     MaxDecoderHeaderTableSize: 0,
	//     MaxEncoderHeaderTableSize: 0,
	// }
	
	_ = server
}

// API 网关 HPACK 调优
package main

import (
	"golang.org/x/net/http2"
	"net/http"
)

func main() {
	server := &http.Server{
		Addr: ":8443",
	}
	
	// 自定义 HTTP/2 配置
	h2Server := &http2.Server{
		// 动态表大小（根据内存预算调整）
		MaxDecoderHeaderTableSize: 8192,
		MaxEncoderHeaderTableSize: 8192,
		
		// 最大帧大小
		MaxReadFrameSize: 1 << 20, // 1MB
		
		// 并发流数
		MaxConcurrentStreams: 1000,
	}
	
	_ = h2Server
	_ = server
}