import (
    "context"
    "log"
    "net/http"
    "github.com/grpc-ecosystem/grpc-gateway/runtime"
    "golang.org/x/net/websocket"
    "google.golang.org/grpc"
)

// 假设你有一个gRPC服务和对应的proto文件定义
// 假设你的gRPC服务有一个方法Invoke(context.Context, *Message) (*Message, error)

// 此函数将WebSocket连接转发到gRPC服务的Invoke方法
func forwardWebsocketToGrpc(w http.ResponseWriter, r *http.Request) {
    // 创建一个WebSocket连接
    ws, err := websocket.NewConfig(r.URL.String(), "websocket", "grpc-websocket-protocol")
    if err != nil {
        log.Println("WebSocket upgrade error:", err)
        http.Error(w, "WebSocket upgrade error", http.StatusInternalServerError)
        return
    }
    ws.TLSConfig = yourTLSConfig // 如果你的服务使用TLS，需要配置TLS
    wsConn := ws.ToConn()
    defer wsConn.Close()

    // 创建gRPC连接
    grpcConn := yourGrpcConnection // 你需要一个有效的gRPC连接
    defer grpcConn.Close()

    // 使用gRPC网关运行时将WebSocket消息转发到gRPC服务
    ctx := runtime.NewServerMetadataContext(context.Background(), nil)
    if err := websocket.Message.Send(wsConn, marshal(invokeRequest)); err != nil { // 发送消息到gRPC服务
        log.Println("Error sending to websocket:", err)
        return
    }
    for {
        var resp proto.Message // 假设你有一个protobuf响应消息
        if err := websocket.Message.Receive(wsConn, &resp); err != nil { // 从gRPC服务接收消息
            log.Println("Error receiving from websocket:", err)
            break
        }
        // 处理gRPC响应消息
    }
}

func main() {
    // 你需要设置gRPC服务器和注册服务
    grpcServer := grpc.NewServer()
    RegisterYourServiceServer(grpcServer, &yourServiceServer{})
    lis, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    go grpcServer.Serve(lis)

    // 设置HTTP服务器和注册转发处理函数
    http.HandleFunc("/websocket/invoke", forwardWebsocketToGrpc)
    log.Fatal(http.ListenAndServe(":8081", nil))
}

go get github.com/cs3238-2021/go-trpc

// hello.proto
syntax = "proto3";

package pb;

service Hello {
  rpc Hello(HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

trpc-go-gen -in hello.proto -out .

package main

import (
    "context"
    "fmt"
    "github.com/cs3238-2021/go-trpc/examples/helloworld/pb"
)

type helloService struct{}

func (h *helloService) Hello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloResponse, error) {
    return &pb.HelloResponse{Message: "Hello, " + req.Name + "!"}, nil
}

func main() {
    server := trpc.NewServer()
    server.Register(new(helloService))
    // ... start the server
}

package main

import (
    "context"
    "fmt"
    "log"
    "net"

    "github.com/cs3238-2021/go-trpc/examples/helloworld/pb"
)

func main() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()

    server := trpc.NewServer()
    server.Register(new(helloService))

    go func() {
        if err := server.Serve(listener); err != nil {
            log.Fatal(err)
        }
    }()

    client := trpc.NewClient(listener.Addr().String())
    resp, err := client.Call(context.Background(), &pb.HelloRequest{Name: "World"})
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(resp.(*pb.HelloResponse).Message)
}

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    "google.golang.org/protobuf/types/known/emptypb"
)

// 假设你有以下的gRPC protobuf定义
// syntax = "proto3";
// package example;
//
// service Greeter {
//   rpc Greet(google.protobuf.Empty) returns (google.protobuf.Empty);
// }

// GreeterServer 是服务器结构体
type GreeterServer struct {
    // ...
}

// Greet 实现 GreeterService 中定义的 Greet 方法
func (s *GreeterServer) Greet(ctx context.Context, _ *emptypb.Empty) (*emptypb.Empty, error) {
    // 实现你的逻辑
    log.Print("Greeting called")
    return &emptypb.Empty{}, nil
}

func main() {
    // 创建 gRPC 服务器
    rpcServer := grpc.NewServer()
    // 注册服务
    greeterServer := &GreeterServer{}
    RegisterGreeterServiceServer(rpcServer, greeterServer)

    // 监听本地端口
    listener, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    // 服务启动循环
    log.Println("Serving gRPC on 0.0.0.0:50051")
    if err := rpcServer.Serve(listener); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

package main

import (
    "context"
    "log"
    "net/http"

    "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
    "google.golang.org/grpc"
)

func run() error {
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    mux := runtime.NewServeMux()
    opts := []grpc.DialOption{grpc.WithInsecure()}
    err := mux.HandlePath(http.MethodGet, "/example.ExampleService/ExampleMethod", handler(opts))
    if err != nil {
        return err
    }

    err = mux.HandlePath(http.MethodPost, "/example.ExampleService/ExampleMethod", handler(opts))
    if err != nil {
        return err
    }

    // 假设 gRPC 服务运行在 localhost:50051
    err = http.ListenAndServe(":8080", mux)
    if err != nil {
        return err
    }
    return nil
}

func handler(opts []grpc.DialOption) runtime.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) {
        // 这里可以添加自定义的处理逻辑
        log.Printf("Forwarding %s %s to gRPC server\n", r.Method, r.URL.Path)
    }
}

func main() {
    if err := run(); err != nil {
        log.Fatal(err)
    }
}