// Copyright 2019 github.com. All rights reserved.
// Use of this source code is governed by github.com.

package pb

import (
	fmt "fmt"
	"property-household-gateway/parser"
	"time"

	"go.etcd.io/etcd/client/v3/naming/resolver"
	grpc "google.golang.org/grpc"
	"google.golang.org/grpc/keepalive"
)

// 客户端集合
var Household HouseholdClient
var Garden GardenClient
var Common CommonClient
var Thirdparty PropertyThirdpartyClient
var System SystemClient
var Device DeviceClient

func setupDeviceClient(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string
	if parser.Conf.K8s {
		serviceName = parser.Conf.Rpc.Device.ServiceName
	} else {
		serviceName = parser.Conf.Rpc.Device.ServiceIp
	}

	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial(fmt.Sprintf("%s:%d", serviceName,
		parser.Conf.Rpc.Device.ServicePort),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Device = NewDeviceClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial Device conn err", err)
	}

	return
}

func setupSystemClient(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string
	if parser.Conf.K8s {
		serviceName = parser.Conf.Rpc.System.ServiceName
	} else {
		serviceName = parser.Conf.Rpc.System.ServiceIp
	}

	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial(fmt.Sprintf("%s:%d", serviceName,
		parser.Conf.Rpc.System.ServicePort),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		System = NewSystemClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial system conn err", err)
	}

	return
}

func setupHouseholdClient(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string
	if parser.Conf.K8s {
		serviceName = parser.Conf.Rpc.Household.ServiceName
	} else {
		serviceName = parser.Conf.Rpc.Household.ServiceIp
	}

	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial(fmt.Sprintf("%s:%d", serviceName,
		parser.Conf.Rpc.Household.ServicePort),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Household = NewHouseholdClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial household conn err", err)
	}

	return
}

func setupGardenClient(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string
	if parser.Conf.K8s {
		serviceName = parser.Conf.Rpc.Garden.ServiceName
	} else {
		serviceName = parser.Conf.Rpc.Garden.ServiceIp
	}

	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial(fmt.Sprintf("%s:%d", serviceName,
		parser.Conf.Rpc.Garden.ServicePort),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Garden = NewGardenClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial garden conn err", err)
	}

	return
}

func setupCommonClient(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string
	if parser.Conf.K8s {
		serviceName = parser.Conf.Rpc.Common.ServiceName
	} else {
		serviceName = parser.Conf.Rpc.Common.ServiceIp
	}

	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial(fmt.Sprintf("%s:%d", serviceName,
		parser.Conf.Rpc.Common.ServicePort),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Common = NewCommonClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial common conn err", err)
	}

	return
}

func setupThirdpartyClient(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string
	if parser.Conf.K8s {
		serviceName = parser.Conf.Rpc.Thirdparty.ServiceName
	} else {
		serviceName = parser.Conf.Rpc.Thirdparty.ServiceIp
	}

	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial(fmt.Sprintf("%s:%d", serviceName,
		parser.Conf.Rpc.Thirdparty.ServicePort),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Thirdparty = NewPropertyThirdpartyClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial thirdparty conn err", err)
	}

	return
}

func setupDeviceClient2(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string

	serviceName = parser.Conf.Rpc.Device.ServiceName

	builder, err := resolver.NewBuilder(parser.GetEtcdClient())
	if err != nil {
		panic(err)
	}
	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial("etcd:///"+parser.Conf.Rpc.Prefix+"/"+serviceName,
		grpc.WithResolvers(builder),
		grpc.WithBalancerName("round_robin"),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Device = NewDeviceClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial Device conn err", err)
	}

	return
}

func setupSystemClient2(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string

	serviceName = parser.Conf.Rpc.System.ServiceName

	builder, err := resolver.NewBuilder(parser.GetEtcdClient())
	if err != nil {
		panic(err)
	}
	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial("etcd:///"+parser.Conf.Rpc.Prefix+"/"+serviceName,
		grpc.WithResolvers(builder),
		grpc.WithBalancerName("round_robin"),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		System = NewSystemClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial system conn err", err)
	}

	return
}

func setupHouseholdClient2(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string

	serviceName = parser.Conf.Rpc.Household.ServiceName

	builder, err := resolver.NewBuilder(parser.GetEtcdClient())
	if err != nil {
		panic(err)
	}
	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial("etcd:///"+parser.Conf.Rpc.Prefix+"/"+serviceName,
		grpc.WithResolvers(builder),
		grpc.WithBalancerName("round_robin"),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Household = NewHouseholdClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial Household conn err", err)
	}

	return
}

func setupGardenClient2(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string

	serviceName = parser.Conf.Rpc.Garden.ServiceName

	builder, err := resolver.NewBuilder(parser.GetEtcdClient())
	if err != nil {
		panic(err)
	}
	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial("etcd:///"+parser.Conf.Rpc.Prefix+"/"+serviceName,
		grpc.WithResolvers(builder),
		grpc.WithBalancerName("round_robin"),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Garden = NewGardenClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial Garden conn err", err)
	}

	return
}

func setupCommonClient2(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string

	serviceName = parser.Conf.Rpc.Common.ServiceName

	builder, err := resolver.NewBuilder(parser.GetEtcdClient())
	if err != nil {
		panic(err)
	}
	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial("etcd:///"+parser.Conf.Rpc.Prefix+"/"+serviceName,
		grpc.WithResolvers(builder),
		grpc.WithBalancerName("round_robin"),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Common = NewCommonClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial Common conn err", err)
	}

	return
}

func setupThirdpartyClient2(kacp keepalive.ClientParameters, conns []*grpc.ClientConn) {
	// 根据是否为k8s来组装targets
	var serviceName string

	serviceName = parser.Conf.Rpc.Thirdparty.ServiceName

	builder, err := resolver.NewBuilder(parser.GetEtcdClient())
	if err != nil {
		panic(err)
	}
	// 发起一个连接并记录连接conn，后期释放
	if conn, err := grpc.Dial("etcd:///"+parser.Conf.Rpc.Prefix+"/"+serviceName,
		grpc.WithResolvers(builder),
		grpc.WithBalancerName("round_robin"),
		grpc.WithInsecure(), grpc.WithKeepaliveParams(kacp)); err == nil {
		Thirdparty = NewPropertyThirdpartyClient(conn)
		conns = append(conns, conn)
	} else {
		fmt.Println("[rpc] dial Thirdparty conn err", err)
	}

	return
}

// SetupClients 创建客户端
func SetupClients() (conns []*grpc.ClientConn) {
	// 客户端配置参数
	var kacp = keepalive.ClientParameters{
		// send pings every n seconds if there is no activity
		Time: time.Duration(parser.Conf.Rpc.Keepalive.ClientTime) * time.Second,
		// wait n second for ping ack before considering the connection dead
		Timeout: time.Duration(parser.Conf.Rpc.Keepalive.ClientTimeout) * time.Second,
		// send pings even without active streams
		PermitWithoutStream: true,
	}
	if len(parser.Conf.EtcdAddrs) == 0 {
		setupHouseholdClient(kacp, conns)
		setupGardenClient(kacp, conns)
		setupCommonClient(kacp, conns)
		setupThirdpartyClient(kacp, conns)
		setupSystemClient(kacp, conns)
		setupDeviceClient(kacp, conns)
		return
	}
	setupHouseholdClient2(kacp, conns)
	setupGardenClient2(kacp, conns)
	setupCommonClient2(kacp, conns)
	setupThirdpartyClient2(kacp, conns)
	setupSystemClient2(kacp, conns)
	setupDeviceClient2(kacp, conns)
	return
}