import struct
from dataclasses import dataclass
from enum import IntEnum

class FrameType(IntEnum):
    DATA = 0x0
    HEADERS = 0x1
    PRIORITY = 0x2
    RST_STREAM = 0x3
    SETTINGS = 0x4
    PUSH_PROMISE = 0x5
    PING = 0x6
    GOAWAY = 0x7
    WINDOW_UPDATE = 0x8
    CONTINUATION = 0x9

@dataclass
class Frame:
    length: int        # 24 bits
    type: int          # 8 bits
    flags: int         # 8 bits
    stream_id: int     # 31 bits
    payload: bytes
    
    HEADER_SIZE = 9
    MAX_LENGTH = 16384  # 16KB default
    
    def encode(self) -> bytes:
        """编码帧为二进制"""
        header = struct.pack(
            '>I',          # 32-bit unsigned int (大端序)
            self.length << 8  # 前 24 位为长度
        )
        # 注意：前 3 字节是长度，需特殊处理
        header = self.length.to_bytes(3, 'big')
        header += self.type.to_bytes(1, 'big')
        header += self.flags.to_bytes(1, 'big')
        header += (self.stream_id & 0x7FFFFFFF).to_bytes(4, 'big')
        return header + self.payload
    
    @classmethod
    def decode(cls, data: bytes) -> 'Frame':
        """从二进制解码帧"""
        if len(data) < cls.HEADER_SIZE:
            raise ValueError("数据不足一个帧头部")
        
        length = int.from_bytes(data[0:3], 'big')
        frame_type = data[3]
        flags = data[4]
        stream_id = int.from_bytes(data[5:9], 'big') & 0x7FFFFFFF
        payload = data[9:9+length]
        
        return cls(length, frame_type, flags, stream_id, payload)

# 示例：创建一个 HEADERS 帧
headers_frame = Frame(
    length=10,
    type=FrameType.HEADERS,
    flags=0x04,  # END_HEADERS
    stream_id=1,
    payload=b'\x82\x86\x84\x41\x0f\x77\x77\x77\x2e'
)
encoded = headers_frame.encode()
print(f"编码后帧大小: {len(encoded)} 字节")
print(f"十六进制: {encoded.hex()}")

def create_data_frame(stream_id: int, data: bytes, end_stream: bool = False) -> Frame:
    """创建 DATA 帧"""
    flags = 0
    if end_stream:
        flags |= 0x01  # END_STREAM
    
    return Frame(
        length=len(data),
        type=FrameType.DATA,
        flags=flags,
        stream_id=stream_id,
        payload=data
    )

# 示例：发送 JSON 响应
response_body = b'{"users": [{"id": 1, "name": "Alice"}]}'
data_frame = create_data_frame(stream_id=1, data=response_body, end_stream=True)

package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		// HTTP/2 中，每个请求对应一个流
		// HEADERS 帧携带以下头部：
		// - :method (GET/POST/...)
		// - :path (/path)
		// - :scheme (https)
		// - :authority (host)
		// + 常规头部 (Content-Type, Accept, ...)
		
		fmt.Fprintf(w, "Stream ID 可在服务端日志中查看\n")
		fmt.Fprintf(w, "Protocol: %s\n", r.Proto)
		
		// 查看接收到的头部
		for name, values := range r.Header {
			for _, v := range values {
				fmt.Fprintf(w, "%s: %s\n", name, v)
			}
		}
	})
	http.ListenAndServeTLS(":8443", "cert.pem", "key.pem", nil)
}

def create_settings_frame(settings: dict) -> Frame:
    """创建 SETTINGS 帧"""
    payload = bytearray()
    for identifier, value in settings.items():
        payload += identifier.to_bytes(2, 'big')
        payload += value.to_bytes(4, 'big')
    
    return Frame(
        length=len(payload),
        type=FrameType.SETTINGS,
        flags=0,
        stream_id=0,  # SETTINGS 帧的 stream_id 必须为 0
        payload=bytes(payload)
    )

# 发送初始 SETTINGS
initial_settings = {
    0x1: 4096,      # HEADER_TABLE_SIZE
    0x2: 1,         # ENABLE_PUSH
    0x3: 100,       # MAX_CONCURRENT_STREAMS
    0x4: 65535,     # INITIAL_WINDOW_SIZE
    0x5: 16384,     # MAX_FRAME_SIZE
}
settings_frame = create_settings_frame(initial_settings)

// Go 中处理 RST_STREAM
package main

import (
	"log"
	"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
	// 客户端取消请求时（如用户关闭页面），
	// 服务器会收到 RST_STREAM
	select {
	case <-r.Context().Done():
		log.Println("客户端取消了请求，收到 RST_STREAM")
		return
	default:
		// 正常处理
		w.Write([]byte("Hello, HTTP/2!"))
	}
}

// 服务端优雅关闭示例
package main

import (
	"context"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Hello"))
	})

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

	// 监听系统信号
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

	go func() {
		<-quit
		log.Println("收到关闭信号，发送 GOAWAY 帧...")
		
		// 优雅关闭：发送 GOAWAY，等待现有请求完成
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cancel()
		
		if err := server.Shutdown(ctx); err != nil {
			log.Printf("关闭错误: %v", err)
		}
	}()

	log.Println("服务器启动 :8443")
	if err := server.ListenAndServeTLS("cert.pem", "key.pem"); err != http.ErrServerClosed {
		log.Fatal(err)
	}
	log.Println("服务器已关闭")
}

from enum import Enum

class StreamState(Enum):
    IDLE = "idle"
    OPEN = "open"
    RESERVED_LOCAL = "reserved (local)"
    RESERVED_REMOTE = "reserved (remote)"
    HALF_CLOSED_LOCAL = "half-closed (local)"
    HALF_CLOSED_REMOTE = "half-closed (remote)"
    CLOSED = "closed"

class Stream:
    def __init__(self, stream_id: int):
        self.stream_id = stream_id
        self.state = StreamState.IDLE
        self.headers = {}
        self.data = bytearray()
        self.window_size = 65535
    
    def on_send_headers(self, end_stream: bool = False):
        if self.state == StreamState.IDLE:
            self.state = StreamState.OPEN
            if end_stream:
                self.state = StreamState.HALF_CLOSED_LOCAL
    
    def on_recv_headers(self, end_stream: bool = False):
        if self.state == StreamState.IDLE:
            self.state = StreamState.OPEN
            if end_stream:
                self.state = StreamState.HALF_CLOSED_REMOTE
    
    def on_send_end_stream(self):
        if self.state == StreamState.OPEN:
            self.state = StreamState.HALF_CLOSED_LOCAL
    
    def on_recv_end_stream(self):
        if self.state == StreamState.OPEN:
            self.state = StreamState.HALF_CLOSED_REMOTE
    
    def on_rst_stream(self):
        self.state = StreamState.CLOSED

# 安装 h2spec
# https://github.com/summerwind/h2spec/releases

# 测试 HTTP/2 服务器的协议合规性
h2spec -t -s -p 8443 localhost

# 输出示例：
# 4.  Frame Format
#   ✓ 4.1.  Frame Format
#     ✓ Sends a frame with unknown type
#     ✓ Sends a frame with invalid length
#   ✓ 4.2.  Frame Size
#     ✓ Sends a DATA frame with 2^14 octets
#     ✓ Sends a DATA frame with 2^24-1 octets

// 自定义 HTTP/2 Transport，监控帧级别信息
package main

import (
	"crypto/tls"
	"fmt"
	"net/http"
	"time"
)

func main() {
	transport := &http.Transport{
		TLSClientConfig: &tls.Config{
			// 启用 HTTP/2
		},
		MaxIdleConns:        100,
		MaxIdleConnsPerHost: 10,
		IdleConnTimeout:     90 * time.Second,
	}

	client := &http.Client{
		Transport: transport,
		Timeout:   30 * time.Second,
	}

	// 发送多个并发请求（验证多路复用）
	urls := []string{
		"https://api.example.com/users",
		"https://api.example.com/orders",
		"https://api.example.com/products",
	}

	for _, url := range urls {
		go func(u string) {
			start := time.Now()
			resp, err := client.Get(u)
			if err != nil {
				fmt.Printf("请求失败 %s: %v\n", u, err)
				return
			}
			defer resp.Body.Close()
			fmt.Printf("[%s] %s - %d (%v)\n", 
				resp.Proto, u, resp.StatusCode, time.Since(start))
		}(url)
	}

	time.Sleep(5 * time.Second)
}