package main

import (
	"flag"
	"net"
	"os"
	"strconv"

	"lone-services/pkg/discovery"
	"lone-services/pkg/redis"
	"lone-services/pkg/utils"
	"lone-services/services/ws/internal/config"
	"lone-services/services/ws/internal/handler"
	"lone-services/services/ws/internal/svc"

	"github.com/zeromicro/go-zero/core/conf"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/rest"
)

var configFile = flag.String("f", "etc/ws.yaml", "the config file")

func main() {
	flag.Parse()
	var c config.Config
	conf.MustLoad(*configFile, &c)

	nacosParam := utils.NacosConfig{
		Hosts:       c.Nacos.Hosts,
		NamespaceId: c.Nacos.NamespaceId,
		Group:       c.Nacos.Group,
		ConfigID:    c.Nacos.ConfigID,
	}
	utils.InitConfig(nacosParam)

	logConf := logx.LogConf{
		ServiceName: utils.GetConfigString("log.serviceName"),
		Mode:        utils.GetConfigString("log.mode"),
		Encoding:    utils.GetConfigString("log.encoding"),
		Level:       utils.GetConfigString("log.level"),
		Path:        utils.GetConfigString("log.path"),
		KeepDays:    utils.GetConfigInt("log.keepDays"),
		MaxSize:     utils.GetConfigInt("log.maxSize"),
		MaxBackups:  utils.GetConfigInt("log.maxBackups"),
		Compress:    utils.GetConfigBool("log.compress"),
	}
	logx.SetUp(logConf)
	logx.AddWriter(logx.NewWriter(os.Stdout))

	listenOn := utils.GetConfigString("base.listenOn")
	serviceName := utils.GetConfigString("base.name")

	if err := discovery.Init(discovery.Config{
		Hosts:       c.Nacos.Hosts,
		NamespaceId: c.Nacos.NamespaceId,
		Group:       c.Nacos.Group,
	}); err != nil {
		logx.Errorf("nacos init: %v", err)
		os.Exit(1)
	}

	_, portStr, err := net.SplitHostPort(listenOn)
	if err != nil {
		logx.Errorf("parse ListenOn: %v", err)
		os.Exit(1)
	}
	port, err := strconv.ParseUint(portStr, 10, 64)
	if err != nil {
		logx.Errorf("parse port: %v", err)
		os.Exit(1)
	}

	if err := discovery.Register(discovery.Instance{
		ServiceName: serviceName,
		IP:          c.Nacos.RegisterIP,
		Port:        port,
		Group:       c.Nacos.Group,
	}); err != nil {
		logx.Errorf("nacos register: %v", err)
		os.Exit(1)
	}
	defer func() {
		if err := discovery.Deregister(); err != nil {
			logx.Errorf("nacos deregister: %v", err)
		}
	}()

	if err := redis.Init(redis.Config{
		Host:     utils.GetConfigString("redis.host"),
		Port:     utils.GetConfigInt("redis.port"),
		Password: utils.GetConfigString("redis.password"),
		DB:       utils.GetConfigInt("redis.db"),
	}); err != nil {
		logx.Errorf("redis init: %v", err)
		os.Exit(1)
	}

	c.Host = "0.0.0.0"
	c.Port = int(port)
	c.Name = serviceName

	server := rest.MustNewServer(c.RestConf)
	defer server.Stop()

	ctx := svc.NewServiceContext(c)
	defer ctx.Close()

	handler.RegisterHandlers(server, ctx)
	logx.Infof("Starting ws-api at %s...", listenOn)

	server.Start()
}