package main

import (
    "errors"
    "log"
    "net/rpc"
    "sync"
    "time"
)

// RPCNode 表示一个远程服务节点
type RPCNode struct {
    Addr string
    client *rpc.Client
    mu sync.Mutex
}

// 确保连接有效
func (n *RPCNode) getClient() (*rpc.Client, error) {
    n.mu.Lock()
    defer n.mu.Unlock()

    // 如果已有连接且正常，复用
    if n.client != nil {
        return n.client, nil
    }

    // 建立新连接
    conn, err := rpc.Dial("tcp", n.Addr)
    if err != nil {
        return nil, err
    }
    n.client = conn
    return conn, nil
}

// LoadBalancer 负载均衡器接口
type LoadBalancer interface {
    Next() (*RPCNode, error)
}

// RoundRobinLB 轮询负载均衡器
type RoundRobinLB struct {
    nodes []*RPCNode
    index int
    mu    sync.Mutex
}

func (lb *RoundRobinLB) Next() (*RPCNode, error) {
    lb.mu.Lock()
    defer lb.mu.Unlock()

    if len(lb.nodes) == 0 {
        return nil, errors.New("no *ailable nodes")
    }

    node := lb.nodes[lb.index%len(lb.nodes)]
    lb.index++
    return node, nil
}

// Call 远程调用入口
func Call(lb LoadBalancer, serviceMethod string, args interface{}, reply interface{}) error {
    node, err := lb.Next()
    if err != nil {
        return err
    }

    client, err := node.getClient()
    if err != nil {
        return err
    }

    return client.Call(serviceMethod, args, reply)
}

func main() {
    nodes := []*RPCNode{
        {Addr: "127.0.0.1:8081"},
        {Addr: "127.0.0.1:8082"},
        {Addr: "127.0.0.1:8083"},
    }

    lb := &RoundRobinLB{nodes: nodes}

    var result string
    err := Call(lb, "HelloService.Say", "world", &result)
    if err != nil {
        log.Fatal(err)
    }
    log.Println("Response:", result)
}

conn, err := grpc.Dial(
    "dns:///my-service.local",
    grpc.WithInsecure(),
    grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`),
)
if err != nil {
    log.Fatal(err)
}