# QUIC 流 ID 编码规则
def stream_info(stream_id: int) -> dict:
    """解析 QUIC 流 ID"""
    initiator = "客户端" if stream_id & 0x01 == 0 else "服务器"
    stream_type = "双向" if stream_id & 0x02 == 0 else "单向"
    return {
        "id": stream_id,
        "initiator": initiator,
        "type": stream_type,
    }

# 示例
for sid in [0, 1, 2, 3, 4, 5, 6, 7]:
    info = stream_info(sid)
    print(f"流 {sid}: {info['initiator']}发起, {info['type']}")

// 模拟连接迁移
package main

import (
	"fmt"
	"net"
)

type QUICConnection struct {
	connectionID []byte
	remoteAddr   *net.UDPAddr
	streams      map[uint32]*QUICStream
}

type QUICStream struct {
	id   uint32
	data []byte
}

func NewQUICConnection(connID []byte, addr *net.UDPAddr) *QUICConnection {
	return &QUICConnection{
		connectionID: connID,
		remoteAddr:   addr,
		streams:      make(map[uint32]*QUICStream),
	}
}

func (c *QUICConnection) Migrate(newAddr *net.UDPAddr) {
	fmt.Printf("连接迁移: %s -> %s\n", c.remoteAddr, newAddr)
	fmt.Printf("Connection ID 不变: %x\n", c.connectionID)
	c.remoteAddr = newAddr
}

func main() {
	connID := []byte{0x12, 0x34, 0x56, 0x78}
	
	// 初始连接
	addr1, _ := net.ResolveUDPAddr("udp4", "192.168.1.100:54321")
	conn := NewQUICConnection(connID, addr1)
	fmt.Printf("初始连接: %s\n", conn.remoteAddr)
	
	// 连接迁移
	addr2, _ := net.ResolveUDPAddr("udp4", "10.0.0.50:12345")
	conn.Migrate(addr2)
}

# 0-RTT 数据的幂等性检查
class ZeroRTTHandler:
    def __init__(self):
        self.seen_requests = set()  # 防重放
        self.max_0rtt_size = 16384  # 16KB 限制
    
    def handle_0rtt_data(self, request_id: str, data: bytes, method: str) -> bool:
        """处理 0-RTT 数据"""
        # 检查重放
        if request_id in self.seen_requests:
            return False  # 拒绝重放
        
        # 只接受幂等方法
        if method not in ("GET", "HEAD", "OPTIONS"):
            return False  # 非幂等方法拒绝 0-RTT
        
        # 检查大小
        if len(data) > self.max_0rtt_size:
            return False
        
        self.seen_requests.add(request_id)
        return True

# 0-RTT 适用场景
# ✓ GET 请求
# ✓ 静态资源加载
# ✓ 缓存验证（If-None-Match）
# ✗ POST/PUT/DELETE
# ✗ 幂等性不确定的操作

// QUIC 拥塞控制接口（简化）
package main

type CongestionControl interface {
    // 数据包发送确认
    OnPacketSent(sentTime int64, packetNumber uint64, bytes int, isRetransmittable bool)
    
    // 收到 ACK
    OnPacketAcked(packetNumber uint64, ackDelay int64)
    
    // 数据包丢失
    OnPacketLost(packetNumber uint64, lostTime int64)
    
    // 获取拥塞窗口
    GetCongestionWindow() int
    
    // 获取慢启动阈值
    GetSlowStartThreshold() int
    
    // 是否在慢启动
    InSlowStart() bool
    
    // 是否在恢复期
    InRecovery() bool
}

// NewReno 拥塞控制实现（简化）
type NewReno struct {
    congestionWindow    int
    slowStartThreshold  int
    bytesInFlight       int
    recoveryStartTime   int64
    maxCongestionWindow int
    minCongestionWindow int
}

func NewNewReno(initialWindow int) *NewReno {
    return &NewReno{
        congestionWindow:   initialWindow,
        slowStartThreshold: 1 << 30, // 初始为极大值
        maxCongestionWindow: 1 << 24, // 16MB
        minCongestionWindow: 2 * 1460, // 2 * MSS
    }
}

func (nr *NewReno) OnPacketAcked(packetNumber uint64, ackDelay int64) {
    if nr.InSlowStart() {
        // 慢启动：指数增长
        nr.congestionWindow += 1460 // MSS
    } else {
        // 拥塞避免：线性增长
        nr.congestionWindow += 1460 * 1460 / nr.congestionWindow
    }
    
    if nr.congestionWindow > nr.maxCongestionWindow {
        nr.congestionWindow = nr.maxCongestionWindow
    }
}

func (nr *NewReno) OnPacketLost(packetNumber uint64, lostTime int64) {
    if nr.InRecovery() {
        return // 已在恢复期
    }
    
    nr.recoveryStartTime = lostTime
    nr.slowStartThreshold = nr.congestionWindow / 2
    nr.congestionWindow = nr.slowStartThreshold
}

func (nr *NewReno) GetCongestionWindow() int         { return nr.congestionWindow }
func (nr *NewReno) GetSlowStartThreshold() int       { return nr.slowStartThreshold }
func (nr *NewReno) InSlowStart() bool                { return nr.congestionWindow < nr.slowStartThreshold }
func (nr *NewReno) InRecovery() bool                 { return false }

// 使用 quic-go 实现 HTTP/3 服务器
package main

import (
	"fmt"
	"log"
	"net/http"

	"github.com/quic-go/quic-go/http3"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Hello, HTTP/3!\n")
		fmt.Fprintf(w, "Protocol: %s\n", r.Proto)
	})

	server := &http3.Server{
		Addr:    ":8443",
		Handler: mux,
	}

	log.Println("HTTP/3 服务器启动于 :8443")
	log.Fatal(server.ListenAndServeTLS("cert.pem", "key.pem"))
}

# 使用 curl 测试 HTTP/3（需要支持 quic 的版本）
curl --http3 https://localhost:8443/

# 使用 quiche 工具
docker run --rm ymuski/curl-http3 curl --http3 -k https://localhost:8443/