// user.proto
syntax = "proto3";

package example;

option go_package = "example/pb";

// 用户消息定义
message User {
  int64 id = 1;
  string name = 2;
  string email = 3;
  UserStatus status = 4;
  repeated string roles = 5;
  map<string, string> metadata = 6;
}

enum UserStatus {
  USER_STATUS_UNSPECIFIED = 0;
  USER_STATUS_ACTIVE = 1;
  USER_STATUS_INACTIVE = 2;
  USER_STATUS_BANNED = 3;
}

// 请求/响应消息
message GetUserRequest {
  int64 id = 1;
}

message GetUserResponse {
  User user = 1;
}

message ListUsersRequest {
  int32 page_size = 1;
  string page_token = 2;
  string filter = 3;
}

message ListUsersResponse {
  repeated User users = 1;
  string next_page_token = 2;
  int32 total_count = 3;
}

// service.proto
syntax = "proto3";

package example;

import "user.proto";

// 用户服务定义
service UserService {
  // 一元 RPC（Unary）
  rpc GetUser(GetUserRequest) returns (GetUserResponse);
  
  // 服务端流式 RPC
  rpc ListUsers(ListUsersRequest) returns (stream User);
  
  // 客户端流式 RPC
  rpc BatchCreateUsers(stream CreateUserRequest) returns (BatchCreateResponse);
  
  // 双向流式 RPC
  rpc WatchUsers(WatchRequest) returns (stream UserEvent);
}

// 辅助消息
message CreateUserRequest {
  string name = 1;
  string email = 2;
}

message BatchCreateResponse {
  repeated User users = 1;
  int32 created_count = 2;
}

message WatchRequest {
  repeated int64 user_ids = 1;
}

message UserEvent {
  enum EventType {
    EVENT_TYPE_UNSPECIFIED = 0;
    EVENT_TYPE_CREATED = 1;
    EVENT_TYPE_UPDATED = 2;
    EVENT_TYPE_DELETED = 3;
  }
  
  EventType type = 1;
  User user = 2;
  int64 timestamp = 3;
}

// 一元 RPC 服务端实现
package main

import (
	"context"
	"log"
	"net"

	pb "example/pb"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

type userService struct {
	pb.UnimplementedUserServiceServer
	users map[int64]*pb.User
}

func (s *userService) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
	user, ok := s.users[req.Id]
	if !ok {
		return nil, status.Errorf(codes.NotFound, "用户 %d 不存在", req.Id)
	}
	return &pb.GetUserResponse{User: user}, nil
}

func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("监听失败: %v", err)
	}

	server := grpc.NewServer()
	pb.RegisterUserServiceServer(server, &userService{
		users: map[int64]*pb.User{
			1: {Id: 1, Name: "Alice", Email: "[email protected]", Status: pb.UserStatus_USER_STATUS_ACTIVE},
			2: {Id: 2, Name: "Bob", Email: "[email protected]", Status: pb.UserStatus_USER_STATUS_ACTIVE},
		},
	})

	log.Println("gRPC 服务器启动于 :50051")
	if err := server.Serve(lis); err != nil {
		log.Fatalf("服务失败: %v", err)
	}
}

// 一元 RPC 客户端
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	pb "example/pb"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	conn, err := grpc.Dial("localhost:50051",
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	if err != nil {
		log.Fatalf("连接失败: %v", err)
	}
	defer conn.Close()

	client := pb.NewUserServiceClient(conn)
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	resp, err := client.GetUser(ctx, &pb.GetUserRequest{Id: 1})
	if err != nil {
		log.Fatalf("调用失败: %v", err)
	}

	fmt.Printf("用户: %s (%s)\n", resp.User.Name, resp.User.Email)
}

def encode_varint(value: int) -> bytes:
    """编码 Varint"""
    result = []
    while value > 0:
        byte = value & 0x7F
        value >>= 7
        if value > 0:
            byte |= 0x80  # 设置继续位
        result.append(byte)
    return bytes(result)

def encode_field(field_number: int, wire_type: int, value) -> bytes:
    """编码字段"""
    tag = (field_number << 3) | wire_type
    result = bytes([tag])
    
    if wire_type == 0:  # Varint
        result += encode_varint(value)
    elif wire_type == 2:  # Length-delimited
        data = value.encode('utf-8') if isinstance(value, str) else value
        result += encode_varint(len(data)) + data
    
    return result

# 编码 User { id: 1, name: "Alice" }
encoded = b""
encoded += encode_field(1, 0, 1)          # id = 1
encoded += encode_field(2, 2, "Alice")    # name = "Alice"

print(f"Protobuf 编码: {encoded.hex()}")
print(f"编码大小: {len(encoded)} 字节")

# JSON 对比
import json
json_data = json.dumps({"id": 1, "name": "Alice"})
print(f"JSON 大小: {len(json_data)} 字节")
print(f"压缩率: {len(encoded)/len(json_data)*100:.1f}%")

# 安装 protoc（Protocol Buffers 编译器）
# Ubuntu/Debian
sudo apt-get install -y protobuf-compiler

# macOS
brew install protobuf

# 验证安装
protoc --version

# 安装 Go 插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# 安装 Python 插件
pip install grpcio grpcio-tools

# 安装 Java 插件（Gradle/Maven 自动管理）

# Go 代码生成
protoc \
  --proto_path=proto \
  --go_out=gen/go --go_opt=paths=source_relative \
  --go-grpc_out=gen/go --go-grpc_opt=paths=source_relative \
  proto/example/*.proto

# Python 代码生成
python -m grpc_tools.protoc \
  --proto_path=proto \
  --python_out=gen/python \
  --grpc_python_out=gen/python \
  proto/example/*.proto

# Java 代码生成
protoc \
  --proto_path=proto \
  --java_out=gen/java \
  --grpc-java_out=gen/java \
  proto/example/*.proto

# Makefile
PROTO_DIR = proto
GEN_DIR = gen

.PHONY: proto
proto:
	@echo "生成 gRPC 代码..."
	protoc \
		--proto_path=$(PROTO_DIR) \
		--go_out=$(GEN_DIR)/go --go_opt=paths=source_relative \
		--go-grpc_out=$(GEN_DIR)/go --go-grpc_opt=paths=source_relative \
		$(PROTO_DIR)/example/*.proto
	@echo "完成"

.PHONY: clean
clean:
	rm -rf $(GEN_DIR)/*

.PHONY: lint
lint:
	buf lint $(PROTO_DIR)

# 性能对比测试
import time
import json
import requests

# REST 方式
def rest_get_user(user_id: int):
    start = time.time()
    resp = requests.get(f"http://localhost:8080/api/users/{user_id}")
    data = resp.json()
    return time.time() - start, len(resp.content)

# gRPC 方式
import grpc
import user_pb2
import user_pb2_grpc

def grpc_get_user(user_id: int):
    channel = grpc.insecure_channel('localhost:50051')
    stub = user_pb2_grpc.UserServiceStub(channel)
    
    start = time.time()
    response = stub.GetUser(user_pb2.GetUserRequest(id=user_id))
    data = response.SerializeToString()
    return time.time() - start, len(data)

# 批量测试
print("=== 单次请求对比 ===")
rest_time, rest_size = rest_get_user(1)
grpc_time, grpc_size = grpc_get_user(1)
print(f"REST:  {rest_time*1000:.2f}ms, {rest_size} bytes")
print(f"gRPC:  {grpc_time*1000:.2f}ms, {grpc_size} bytes")
print(f"速度提升: {rest_time/grpc_time:.1f}x")
print(f"大小节省: {(1-grpc_size/rest_size)*100:.1f}%")

print("\n=== 1000 次请求对比 ===")
rest_total = sum(rest_get_user(i % 100 + 1)[0] for i in range(1000))
grpc_total = sum(grpc_get_user(i % 100 + 1)[0] for i in range(1000))
print(f"REST 总耗时: {rest_total:.2f}s ({1000/rest_total:.0f} QPS)")
print(f"gRPC 总耗时: {grpc_total:.2f}s ({1000/grpc_total:.0f} QPS)")