// user.thrift
namespace go example.user
namespace java example.user
namespace py example.user

// 基本类型
// bool, byte, i16, i32, i64, double, string, binary

// 枚举
enum UserStatus {
  ACTIVE = 1,
  INACTIVE = 2,
  BANNED = 3,
}

// 结构体
struct User {
  1: required i64 id,
  2: required string name,
  3: required string email,
  4: optional UserStatus status = UserStatus.ACTIVE,
  5: optional list<string> roles,
  6: optional map<string, string> metadata,
}

// 异常
exception UserNotFound {
  1: i64 id,
  2: string message,
}

exception InvalidRequest {
  1: string field,
  2: string message,
}

// 服务定义
service UserService {
  // 简单 RPC
  User getUser(1: i64 id) throws (1: UserNotFound err),
  
  void createUser(1: User user) throws (1: InvalidRequest err),
  
  list<User> listUsers(1: i32 page_size, 2: string cursor),
  
  // 单向调用（fire-and-forget）
  oneway void notifyUser(1: i64 id, 2: string message),
}

// advanced.thrift
namespace go example.advanced

// 常量
const i32 MAX_PAGE_SIZE = 100
const string DEFAULT_LANG = "zh-CN"

// 类型别名
typedef map<string, string> Headers
typedef list<User> UserList

// 结构体继承
struct BaseResponse {
  1: required i32 code,
  2: required string message,
}

struct UserResponse extends BaseResponse {
  3: optional User user,
}

// 包含其他 thrift 文件
include "user.thrift"

// 服务继承
service AdminService extends user.UserService {
  void banUser(1: i64 id, 2: string reason),
  list<User> searchUsers(1: string query, 2: i32 limit = MAX_PAGE_SIZE),
}

// 协程安全注解（Go 特有）
service SafeService {
  // cpp 和 go 中生成线程安全代码
  User getUser(1: i64 id),
}(concurrent)

// Go 中使用不同的 Transport
package main

import (
	"github.com/apache/thrift/lib/go/thrift"
)

func createSocketTransport() thrift.TTransport {
	// 原始 TCP
	return thrift.NewTSocketConf("localhost:9090", &thrift.TConfiguration{})
}

func createBufferedTransport() thrift.TTransport {
	socket := thrift.NewTSocketConf("localhost:9090", &thrift.TConfiguration{})
	// 带缓冲，缓冲区 8KB
	return thrift.NewTBufferedTransport(socket, 8192)
}

func createFramedTransport() thrift.TTransport {
	socket := thrift.NewTSocketConf("localhost:9090", &thrift.TConfiguration{})
	// 分帧传输，适合非阻塞服务器
	return thrift.NewTFramedTransportConf(socket, &thrift.TConfiguration{})
}

# Python 中使用不同协议
from thrift.protocol import TBinaryProtocol
from thrift.protocol import TCompactProtocol
from thrift.protocol import TJSONProtocol
from thrift.transport import TSocket, TTransport

# 二进制协议（默认，推荐）
def create_binary_client(host, port):
    transport = TSocket.TSocket(host, port)
    transport = TTransport.TBufferedTransport(transport)
    protocol = TBinaryProtocol.TBinaryProtocol(transport)
    transport.open()
    return protocol

# 紧凑协议（更小的编码体积）
def create_compact_client(host, port):
    transport = TSocket.TSocket(host, port)
    transport = TTransport.TBufferedTransport(transport)
    protocol = TCompactProtocol.TCompactProtocol(transport)
    transport.open()
    return protocol

# JSON 协议（便于调试）
def create_json_client(host, port):
    transport = TSocket.TSocket(host, port)
    transport = TTransport.TBufferedTransport(transport)
    protocol = TJSONProtocol.TJSONProtocol(transport)
    transport.open()
    return protocol

# 安装 Thrift 编译器
# Ubuntu
sudo apt-get install thrift-compiler
# macOS
brew install thrift

# 生成 Go 代码
thrift --gen go user.thrift

# 生成 Python 代码
thrift --gen py user.thrift

# 生成 Java 代码
thrift --gen java user.thrift

# 生成多个语言
thrift --gen go --gen py --gen java user.thrift

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/apache/thrift/lib/go/thrift"
	"example/gen-go/user"
)

// 实现 UserService 接口
type UserHandler struct {
	users map[int64]*user.User
}

func NewUserHandler() *UserHandler {
	return &UserHandler{
		users: map[int64]*user.User{
			1: {Id: 1, Name: "Alice", Email: "[email protected]"},
			2: {Id: 2, Name: "Bob", Email: "[email protected]"},
		},
	}
}

func (h *UserHandler) GetUser(ctx context.Context, id int64) (*user.User, error) {
	u, ok := h.users[id]
	if !ok {
		return nil, &user.UserNotFound{
			Id:      id,
			Message: fmt.Sprintf("用户 %d 不存在", id),
		}
	}
	return u, nil
}

func (h *UserHandler) CreateUser(ctx context.Context, u *user.User) error {
	if u.Name == "" {
		return &user.InvalidRequest{
			Field:   "name",
			Message: "用户名不能为空",
		}
	}
	h.users[u.Id] = u
	return nil
}

func (h *UserHandler) ListUsers(ctx context.Context, pageSize int32, cursor string) ([]*user.User, error) {
	result := make([]*user.User, 0, len(h.users))
	for _, u := range h.users {
		result = append(result, u)
		if int32(len(result)) >= pageSize {
			break
		}
	}
	return result, nil
}

func (h *UserHandler) NotifyUser(ctx context.Context, id int64, message string) error {
	log.Printf("通知用户 %d: %s", id, message)
	return nil
}

func main() {
	handler := NewUserHandler()
	processor := user.NewUserServiceProcessor(handler)
	
	transport, err := thrift.NewTServerSocket(":9090")
	if err != nil {
		log.Fatalf("创建 socket 失败: %v", err)
	}

	// 使用 TFramedTransport + TBinaryProtocol
	transportFactory := thrift.NewTFramedTransportFactoryConf(
		thrift.NewTTransportFactory(),
		&thrift.TConfiguration{},
	)
	protocolFactory := thrift.NewTBinaryProtocolFactoryConf(&thrift.TConfiguration{})

	server := thrift.NewTSimpleServer4(
		processor,
		transport,
		transportFactory,
		protocolFactory,
	)

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

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/apache/thrift/lib/go/thrift"
	"example/gen-go/user"
)

func main() {
	socket := thrift.NewTSocketConf("localhost:9090", &thrift.TConfiguration{})
	transport := thrift.NewTFramedTransportConf(socket, &thrift.TConfiguration{})
	protocol := thrift.NewTBinaryProtocolFactoryConf(&thrift.TConfiguration{})

	if err := transport.Open(); err != nil {
		log.Fatalf("连接失败: %v", err)
	}
	defer transport.Close()

	client := user.NewUserServiceClientFactory(transport, protocol)

	// 获取用户
	u, err := client.GetUser(context.Background(), 1)
	if err != nil {
		if notFound, ok := err.(*user.UserNotFound); ok {
			fmt.Printf("用户不存在: %s\n", notFound.Message)
		} else {
			log.Fatalf("调用失败: %v", err)
		}
	} else {
		fmt.Printf("用户: %s (%s)\n", u.Name, u.Email)
	}

	// 创建用户
	newUser := &user.User{
		Id:    3,
		Name:  "Charlie",
		Email: "[email protected]",
	}
	if err := client.CreateUser(context.Background(), newUser); err != nil {
		log.Fatalf("创建失败: %v", err)
	}
	fmt.Println("用户创建成功")
}