package main

import (
	"github.com/nats-io/nats.go"
	"github.com/redis/go-redis/v9"
	clientv3 "go.etcd.io/etcd/client/v3"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"sonet/internal/gateway_ws/gws_server"
	"sonet/internal/postal/group"
	"sonet/internal/postal/logic"
	"sonet/pkg/config"
	"sonet/pkg/grpc/client"
	"sonet/pkg/grpc/discovery"
	"sonet/pkg/grpc/discovery/etcd"
	"sonet/pkg/grpc/generic"
	"sonet/pkg/plugins/cache"
	"sonet/pkg/plugins/mq"
	"sonet/pkg/protocol/session"
	"sonet/pkg/utils/collect"
	"sonet/pkg/utils/conver"
	"sonet/pkg/utils/shutdown"
)

type GatewayWsConfig struct {
	HttpPort        int
	EndpointAddress string

	SubjectCacheTopic         string
	SubjectLrcExpiration      string
	SubjectLrcCleanupInterval string
}

// websocket server with postalService
func main() {
	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())

	subjectStore, producer, err := getSubjectMultiCache(appConf, conf.Redis, conf.Nats)
	if err != nil {
		panic(err)
	}

	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(postalAddr, grpcFactory, sessionStore, subjectStore)
	httpServer := gws_server.NewGwsServer(gwsHandler)
	httpServer.Init()

	go func() {
		err = httpServer.Run(appConf.HttpPort)
		if err != nil {
			panic(err)
		}
	}()

	// run postal server
	clientFactory := client.NewGrpcDirectClientFactory(grpc.WithTransportCredentials(insecure.NewCredentials()))
	postalServer := logic.NewPostalServer(appConf.EndpointAddress, sessionStore, groupStore, subjectStore, clientFactory, producer)
	go func() {
		err = postalServer.Run(conf.Grpc, dis)
		if err != nil {
			panic(err)
		}
	}()

	// run postal cluster server
	postalClusterServer := logic.NewPostalClusterServer(postalServer)
	go func() {
		err := postalClusterServer.Run(conf.Grpc.Address, config.GetGrpcOptions(conf.Grpc)...)
		if err != nil {
			panic(err)
		}
	}()

	shutdown.Await()
}

func getSubjectMultiCache(appConf *GatewayWsConfig, redisOptions redis.Options, natsOptions nats.Options) (*cache.LocalRemoteCache, mq.Producer, error) {
	// initial cache...
	rdb := redis.NewClient(&redisOptions)
	subjectRedisCache := cache.NewRedisCache(appConf.SubjectCacheTopic, rdb)
	shutdown.AddHook(func() { _ = rdb.Close() })

	// nats mq
	producer, err := mq.NewNatsProducer(natsOptions)
	if err != nil {
		return nil, nil, err
	}
	shutdown.AddHook(func() { producer.Stop() })
	consumer, err := mq.NewNatsConsumer(natsOptions)
	if err != nil {
		return nil, nil, err
	}
	shutdown.AddHook(func() { consumer.Stop() })

	// 多级缓存
	subjectLrcOpts := cache.LocalRemoteCacheOptions{
		Topic:           appConf.SubjectCacheTopic,
		LocalExpiration: conver.MustParseDuration(appConf.SubjectLrcExpiration),
		CleanupInterval: conver.MustParseDuration(appConf.SubjectLrcCleanupInterval),
		Remote:          subjectRedisCache,
		Producer:        producer,
		Consumer:        consumer,
	}
	subjectLrc, err := cache.NewLocalRemoteCache(subjectLrcOpts)
	return subjectLrc, producer, err
}