package main

import (
	"admin/admin"
	"flag"
	"fmt"
	"net"
	"os"
	"strconv"

	"admin/internal/config"
	"admin/internal/server"
	"admin/internal/svc"

	"github.com/zeromicro/go-zero/core/conf"
	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/service"
	"github.com/zeromicro/go-zero/zrpc"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
	"pkg.local/discovery"
	"pkg.local/log"
	"pkg.local/modelbase"
	"pkg.local/mysql"
	"pkg.local/redis"
	"pkg.local/utils"
	"pkg.local/validate"
)

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

func main() {

	flag.Parse()

	var c config.Config
	conf.MustLoad(*configFile, &c)

	if err := log.Init(log.Config{
		Path:       c.AppLog.Path,
		InfoFile:   c.AppLog.InfoFile,
		ErrorFile:  c.AppLog.ErrorFile,
		FatalFile:  c.AppLog.FatalFile,
		MaxSize:    c.AppLog.MaxSize,
		MaxBackups: c.AppLog.MaxBackups,
		MaxAge:     c.AppLog.MaxAge,
	}); err != nil {
		fmt.Fprintf(os.Stderr, "log init: %v\n", err)
		os.Exit(1)
	}

	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)
	}

	registerIP := c.Nacos.RegisterIP
	port, err := listenPort(c.ListenOn)
	if err != nil {
		logx.Errorf("parse ListenOn: %v", err)
	}

	if err := discovery.Register(discovery.Instance{
		ServiceName: c.Name,
		IP:          registerIP,
		Port:        port,
		Group:       c.Nacos.Group,
	}); err != nil {
		logx.Errorf("nacos register: %v", err)
	}

	defer func() {
		if err := discovery.Deregister(); err != nil {
			logx.Errorf("nacos deregister: %v", err)
		}
	}()

	db, err := mysql.New(mysql.Config{
		Host:         c.Mysql.Host,
		Port:         c.Mysql.Port,
		User:         c.Mysql.User,
		Password:     c.Mysql.Password,
		Database:     c.Mysql.Database,
		Charset:      c.Mysql.Charset,
		Prefix:       c.Mysql.Prefix,
		ReadHost:     c.Mysql.ReadHost,
		ReadPort:     c.Mysql.ReadPort,
		ReadUser:     c.Mysql.ReadUser,
		ReadPassword: c.Mysql.ReadPassword,
		ReadDatabase: c.Mysql.ReadDatabase,
	})
	if err != nil {
		logx.Errorf("mysql init: %v", err)
	}

	if err := redis.Init(redis.Config{
		Host:     c.BizRedis.Host,
		Port:     c.BizRedis.Port,
		Password: c.BizRedis.Password,
		DB:       c.BizRedis.DB,
	}); err != nil {
		logx.Errorf("redis init: %v", err)
	}

	debug := utils.GetConfigBool("mysql.debug")
	modelbase.Init(db, modelbase.Config{Prefix: c.Mysql.Prefix, Debug: debug})

	ctx := svc.NewServiceContext(c, db)

	s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
		admin.RegisterAdminServer(grpcServer, server.NewAdminServer(ctx))

		if c.Mode == service.DevMode || c.Mode == service.TestMode {
			reflection.Register(grpcServer)
		}
	})
	defer s.Stop()

	logx.AddWriter(logx.NewWriter(os.Stdout))

	s.AddUnaryInterceptors(validate.UnaryServerInterceptor(validate.MustNew()))

	logx.Infof("Starting rpc server at %s...", c.ListenOn)
	s.Start()
}

func listenPort(listenOn string) (uint64, error) {
	_, portStr, err := net.SplitHostPort(listenOn)
	if err != nil {
		return 0, err
	}
	return strconv.ParseUint(portStr, 10, 64)
}