package main

import (
	"fmt"
	"net"
	"sig-pub/api/pb"
	"sig-pub/internal/exchange"
	"sig-pub/internal/exchange/okx"
	"sig-pub/pkg/aside"
	"sig-pub/pkg/config"
	"sig-pub/pkg/grpc/discovery"
	"sig-pub/pkg/grpc/interceptor"
	"sig-pub/pkg/storage/kvrocks"
	vmts "sig-pub/pkg/storage/tsdb/victoria_metrics"
	"sig-pub/pkg/utils/exit"
	"sig-pub/pkg/zlog"

	"github.com/hashicorp/consul/api"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/reflection"
)

type ExchangeConf struct {
	Register       discovery.Server
	GrpcReflection bool
}

func main() {
	// load config
	conf := config.MustLoadConfig(new(config.Configuration), "config/config.toml")
	exchangeConf := config.MustLoadConfig(new(ExchangeConf), "config/exchange.toml")

	// etcdClient, err := clientv3.New(conf.Etcd)
	// if err != nil {
	// 	panic(err)
	// }
	// exit.AddHook(func() { _ = etcdClient.Close() }, exit.WithOrderTail())

	// get market grpc client
	// dis := discovery.NewEtcdDiscovery(etcdClient)
	// resolver, err := dis.Resolver()
	// if err != nil {
	// 	panic(err)
	// }

	// Consul 配置
	cc := api.DefaultConfig()
	cc.Address = conf.Consul.Address // Consul 地址
	client, err := api.NewClient(cc)
	if err != nil {
		panic(fmt.Errorf("consul client error: %v", err))
	}
	dis := discovery.NewConsulDiscovery(client)
	resolver := dis.Resolver()

	// new market grpc client
	marketUrl := discovery.ConsulDialUrl(pb.Market_ServiceDesc.ServiceName)
	marketConn, err := grpc.NewClient(marketUrl,
		grpc.WithResolvers(resolver),
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	if err != nil {
		panic(err)
	}
	marketClient := pb.NewMarketClient(marketConn)
	tradeInstanceAside := aside.NewTradeInstanceAside(marketClient)

	// kvrocks db
	kvdb := kvrocks.NewKVRocksDB(conf.Database.Kvrocks)
	if err := kvdb.Ping(); err != nil {
		panic(err)
	}

	// okx exchange
	okxSubscriber := okx.NewOkxSubscriber(conf.Exchange.Okx)
	if err := okxSubscriber.Init(); err != nil {
		panic(err)
	}
	okxFetcher := okx.NewOkxFetcher(conf.Exchange.Okx.HttpProxy)
	okxExchange := exchange.NewExchange(okxFetcher, okxSubscriber)

	// tsdb VictoriaMetrics
	vmtsdb := vmts.NewVictoriaMetricsTSDB(conf.Tsdb.Victoriametrics)
	tsdbService := exchange.NewExchangeDataService(vmtsdb, nil)
	if err := tsdbService.Init(); err != nil {
		panic(err)
	}

	// exhcange main service
	exchangeService := exchange.NewExchangeGrpcServer(tradeInstanceAside, tsdbService, kvdb, okxExchange)
	if err := exchangeService.Init(); err != nil {
		panic(err)
	}

	grpcServer := grpc.NewServer(config.GetGrpcOptions(
		conf.Grpc,
		grpc.UnaryInterceptor(interceptor.RecoverInterceptor))...,
	)
	if exchangeConf.GrpcReflection {
		// 注册反射服务
		reflection.Register(grpcServer)
	}
	pb.RegisterExchangeServiceServer(grpcServer, exchangeService)

	exit.AddHook(grpcServer.GracefulStop, exit.WithOrderFront())

	// consul 服务注册
	register := exchangeConf.Register
	if register.Name == "" {
		register.Name = pb.ExchangeService_ServiceDesc.ServiceName
	}
	if err := dis.Registry(grpcServer, register); err != nil {
		panic(err)
	}
	zlog.Info("service registered to consul")

	// run grpc server
	go func() {
		listen, err := net.Listen("tcp", exchangeConf.Register.Addr)
		if err != nil {
			panic(err)
		}
		zlog.Infof("%s grpc server running %s\n", register.Name, listen.Addr().String())
		if err := grpcServer.Serve(listen); err != nil {
			panic(err)
		}
	}()

	exit.Await()
}