package main

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"net/http"
	"os"
	"strconv"
	"strings"

	_ "net/http/pprof"

	"nms_cxy/features/dbrest"
	"nms_cxy/features/event"
	"nms_cxy/features/fm"
	"nms_cxy/features/lm"
	"nms_cxy/features/mml"
	"nms_cxy/features/pm"
	"nms_cxy/lib/dborm"
	"nms_cxy/lib/global"
	"nms_cxy/lib/log"
	"nms_cxy/lib/routes"
	"nms_cxy/omc/config"
	"nms_cxy/src"
	"nms_cxy/src/framework/middleware"

	"github.com/gin-gonic/gin"
	"golang.org/x/net/http2"
	"golang.org/x/net/http2/h2c"
)

func HttpListen(addr string, router http.Handler) {
	// 创建HTTP服务器
	h2s := &http2.Server{
		// ...
	}
	server := &http.Server{
		Addr:    addr,
		Handler: h2c.NewHandler(router, h2s),
	}

	err := server.ListenAndServe()
	if err != nil {
		fmt.Println("ListenAndServe err:", err)
		os.Exit(12)
	}
}

func HttpListenTLS(addr, caFile, certFile, keyFile string, clientAuthType int, router http.Handler) {
	// 加载根证书
	caCert, err := os.ReadFile(caFile)
	if err != nil {
		log.Fatal(err)
	}
	caCertPool := x509.NewCertPool()
	caCertPool.AppendCertsFromPEM(caCert)

	// 创建自定义的TLS配置
	tlsConfig := &tls.Config{
		MinVersion: tls.VersionTLS10,
		MaxVersion: tls.VersionTLS13,
		ClientCAs:  caCertPool,
		ClientAuth: tls.ClientAuthType(clientAuthType),
	}

	// 创建HTTP服务器
	server := &http.Server{
		Addr:      addr,
		Handler:   router,
		TLSConfig: tlsConfig,
	}

	// support http 2.0 server
	http2.ConfigureServer(server, &http2.Server{})
	if err != nil {
		fmt.Println("ConfigureServer err:", err)
		os.Exit(13)
	}
	err = server.ListenAndServeTLS(certFile, keyFile)
	if err != nil {
		fmt.Println("ListenAndServeTLS err:", err)
		os.Exit(14)
	}
}

func HttpListenWebServerTLS(addr, caFile, certFile, keyFile string, clientAuthType int) {
	// 加载根证书
	caCert, err := os.ReadFile(caFile)
	if err != nil {
		log.Fatal(err)
	}
	caCertPool := x509.NewCertPool()
	caCertPool.AppendCertsFromPEM(caCert)

	// 创建自定义的TLS配置
	tlsConfig := &tls.Config{
		MinVersion: tls.VersionTLS10,
		MaxVersion: tls.VersionTLS13,
		ClientCAs:  caCertPool,
		ClientAuth: tls.ClientAuthType(clientAuthType),
	}

	// 创建HTTP服务器
	server := &http.Server{
		Addr:      addr,
		TLSConfig: tlsConfig,
	}

	// support http 2.0 server
	http2.ConfigureServer(server, &http2.Server{})
	if err != nil {
		fmt.Println("ConfigureServer err:", err)
		os.Exit(9)
	}
	err = server.ListenAndServeTLS(certFile, keyFile)
	if err != nil {
		fmt.Println("ListenAndServeTLS err:", err)
		os.Exit(10)
	}
}

func HttpListenWebServer(addr string) {
	// 创建HTTP服务器
	server := &http.Server{
		Addr: addr,
	}

	// support http 2.0 server
	err := http2.ConfigureServer(server, &http2.Server{})
	if err != nil {
		fmt.Println("ConfigureServer err:", err)
		os.Exit(7)
	}
	err = server.ListenAndServe()
	if err != nil {
		fmt.Println("ListenAndServe err:", err)
		os.Exit(8)
	}
}

func main() {

	// src 配置中心初始加载
	src.ConfigurationInit()
	app := src.AppEngine()

	conf := config.GetYamlConfig()

	if conf.Pprof.Enabled {
		// 启用pprof HTTP服务
		go func() {
			fmt.Println(http.ListenAndServe(conf.Pprof.Addr, nil))
		}()
	}

	log.InitLogger(conf.Logger.File, conf.Logger.Duration, conf.Logger.Count, "omc:", config.GetLogLevel())
	fmt.Printf("OMC version: %s\n", global.Version)
	log.Infof("========================= OMC startup =========================")
	log.Infof("OMC version: %s %s %s", global.Version, global.BuildTime, global.GoVer)

	err := dborm.InitDbClient(conf.Database.Type, conf.Database.User, conf.Database.Password,
		conf.Database.Host, conf.Database.Port, conf.Database.Name, conf.Database.ConnParam)
	if err != nil {
		fmt.Println("dborm.initDbClient err:", err)
		os.Exit(4)
	}
	err = fm.InitDbClient(conf.Database.Type, conf.Database.User, conf.Database.Password,
		conf.Database.Host, conf.Database.Port, conf.Database.Name, conf.Database.ConnParam)
	if err != nil {
		fmt.Println("dborm.initDbClient err:", err)
		os.Exit(4)
	}
	err = pm.InitDbClient(conf.Database.Type, conf.Database.User, conf.Database.Password,
		conf.Database.Host, conf.Database.Port, conf.Database.Name, conf.Database.ConnParam)
	if err != nil {
		fmt.Println("dborm.initDbClient err:", err)
		os.Exit(4)
	}
	err = dbrest.InitDbClient(conf.Database.Type, conf.Database.User, conf.Database.Password,
		conf.Database.Host, conf.Database.Port, conf.Database.Name, conf.Database.ConnParam)
	if err != nil {
		fmt.Println("dbrest.initDbClient err:", err)
		os.Exit(4)
	}
	err = lm.InitDbClient(conf.Database.Type, conf.Database.User, conf.Database.Password,
		conf.Database.Host, conf.Database.Port, conf.Database.Name, conf.Database.ConnParam)
	if err != nil {
		fmt.Println("lm.initDbClient err:", err)
		os.Exit(4)
	}

	mml.InitMML()

	// 将 mux.Router 注册到 gin.Engine

	// 默认路由组
	defaultUriGroup := app.Group(config.DefaultUriPrefix)
	defaultUriGroup.Use(middleware.PreAuthorize(nil))
	defaultUriGroup.Any("/*any", gin.WrapH(routes.NewRouter()))
	// 可配置前缀路由组
	uriGroup := app.Group(config.UriPrefix)
	uriGroup.Any("/*any", gin.WrapH(routes.NewRouter()))
	// AMF上报的UE事件, 无前缀，暂时特殊处理
	app.POST(event.UriUEEventAMF, event.PostUEEventFromAMF)

	for _, rest := range conf.Rest {
		// ipv4 goroutines
		if rest.IPv4 != "" {
			listen := rest.IPv4 + ":" + strconv.Itoa(int(rest.Port))
			if strings.ToLower(rest.Scheme) == "https" {
				go HttpListenTLS(listen, rest.CaFile, rest.CertFile, rest.KeyFile, rest.ClientAuthType, app)
			} else {
				go HttpListen(listen, app)
			}
		}
		// ipv6 goroutines
		if rest.IPv6 != "" {
			listenv6 := "[" + rest.IPv6 + "]" + ":" + strconv.Itoa(int(rest.Port))
			if strings.ToLower(rest.Scheme) == "https" {
				go HttpListenTLS(listenv6, rest.CaFile, rest.CertFile, rest.KeyFile, rest.ClientAuthType, app)
			} else {
				go HttpListen(listenv6, app)
			}
		}

	}

	if conf.WebServer.Enabled {
		fs := http.FileServer(http.Dir(conf.WebServer.RootDir))
		http.Handle("/", fs)
		for _, listen := range conf.WebServer.Listen {
			if strings.ToLower(listen.Scheme) == "https" {
				go HttpListenWebServerTLS(listen.Addr, listen.CaFile, listen.CertFile, listen.KeyFile, listen.ClientAuthType)
			} else {
				go HttpListenWebServer(listen.Addr)
			}
		}
	}

	select {}
}