package main

import (
	"context"
	"fmt"
	"github.com/panjf2000/gnet/v2"
	clientv3 "go.etcd.io/etcd/client/v3"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"runtime"
	"sonet/internal/gateway_ws/gnet_server"
	"sonet/internal/postal/group"
	"sonet/internal/postal/logic"
	"sonet/pkg/config"
	"sonet/pkg/grpc/client"
	"sonet/pkg/grpc/discovery"
	"sonet/pkg/grpc/generic"
	"sonet/pkg/plugins/mq"
	"sonet/pkg/protocol/deliver"
	"sonet/pkg/protocol/session"
	"sonet/pkg/utils/collect"
	"sonet/pkg/utils/shutdown"
)

type GatewayWsConfig struct {
	HttpPort        int
	EndpointAddress string

	SubjectCacheTopic         string
	SubjectLrcExpiration      string
	SubjectLrcCleanupInterval string
}

// websocket server with postalService
func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	appConf := &GatewayWsConfig{}
	conf := config.LoadConfig(appConf, "cmd/gateway_ws")

	// registry and run
	etcdClient, err := clientv3.New(conf.Etcd)
	if err != nil {
		panic(err)
	}
	shutdown.AddHook(func() { _ = etcdClient.Close() }, shutdown.WithOrderBack())

	dis := discovery.NewEtcdDiscovery(etcdClient)
	etcdResolver, err := dis.Resolver()
	if err != nil {
		panic(err)
	}
	grpcFactory := generic.NewGpcGenericClientFactory(
		discovery.EtcdSchema,
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithResolvers(etcdResolver),
	)
	grpcFactory.Init()

	sessionStore := session.NewMapStore(128)
	groupStore := collect.NewConcurrentMap[string, *group.Group](128, func(k string) string { return k })

	// run websocket server
	//postalAddr := etcd.MustRegisterAddress(conf.Grpc.Address)
	//connHandler := server.NewConnHandler(postalAddr, grpcFactory, sessionStore, subjectStore)
	//httpServer := server.NewHttpServer(connHandler)
	//gwsHandler := gws_server.NewGwsHandler(grpcFactory, sessionStore)
	//httpServer := gws_server.NewGwsServer(gwsHandler)
	//httpServer.Init()
	//go func() {
	//	err = httpServer.Run(appConf.HttpPort)
	//	if err != nil {
	//		panic(err)
	//	}
	//}()

	ctx, cancel := context.WithCancel(context.Background())
	shutdown.AddHook(cancel)

	go func() {
		gnetWsServer := gnet_server.NewGnetWsServer(grpcFactory, sessionStore)
		gnetWsServer.Init(ctx)
		err := gnet.Run(gnetWsServer,
			fmt.Sprintf("tcp://0.0.0.0:%d", appConf.HttpPort),
			gnet.WithMulticore(true),
			gnet.WithReusePort(true),
			gnet.WithTicker(true),
		)
		if err != nil {
			panic(err)
		}
	}()

	// run postal cluster server
	postalPicker := deliver.NewPostalPicker(dis, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err = postalPicker.Init(ctx); err != nil {
		panic(err)
	}
	clientFactory := client.NewGrpcDirectClientFactory(grpc.WithTransportCredentials(insecure.NewCredentials()))
	postalClusterServer := logic.NewPostalClusterServer(sessionStore, postalPicker, clientFactory)
	go func() {
		err := postalClusterServer.Run(conf.Grpc.Address, config.GetGrpcOptions(conf.Grpc)...)
		if err != nil {
			panic(err)
		}
	}()

	// run postal server
	// nats mq
	producer, err := mq.NewNatsProducer(conf.Nats)
	if err != nil {
		panic(err)
	}
	shutdown.AddHook(producer.Stop)
	postalServer := logic.NewPostalServer(appConf.EndpointAddress, sessionStore, groupStore, postalClusterServer, producer)
	go func() {
		err = postalServer.Run(conf.Grpc, dis)
		if err != nil {
			panic(err)
		}
	}()

	shutdown.Await()
}