package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"git.x2erp.com/qdy/go-base/config"
	"git.x2erp.com/qdy/go-base/types"
	"git.x2erp.com/qdy/go-db/factory/database"
	"git.x2erp.com/qdy/go-service-agent/auth"
	"git.x2erp.com/qdy/go-service-agent/functions"
	"github.com/gin-gonic/gin"
)

func main() {

	cfg := config.GetConfig()

	log.Printf("Service Port: %d", cfg.GetService().Port)
	log.Printf("Service IdleTimeout: %d", cfg.GetService().IdleTimeout)
	log.Printf("Service ReadTimeout: %d", cfg.GetService().ReadTimeout)
	log.Printf("Service WriteTimeout: %d", cfg.GetService().WriteTimeout)
	log.Printf("Service TrustedProxies: %s", cfg.GetService().TrustedProxies)

	log.Printf("Using database type: %s", cfg.GetDatabase().Type)
	log.Printf("Database host: %s:%d", cfg.GetDatabase().Host, cfg.GetDatabase().Port)
	log.Printf("Database name: %s", cfg.GetDatabase().Database)
	log.Println("Database connection test passed!")

	// 3. 启动Gin HTTP服务
	startHTTPServer()
}

// 启动HTTP服务器
func startHTTPServer() {
	//建立路由
	router := gin.Default()
	cfg := config.GetConfig()
	serviceConfig := cfg.GetService()

	dbFactory, err := database.GetDBFactory()
	if err != nil {
		log.Fatalf("Failed to create DB factory: %v", err)
	}
	// 设置优雅关闭
	setupGracefulShutdown(dbFactory)
	defer func() {
		dbFactory.Close()
		log.Println("Database connection closed")
	}()

	// 核心路由
	router.GET("/api/health", functions.HealthHandler(dbFactory, cfg.GetDatabase().Type))
	router.POST("/api/query", auth.AuthMiddleware(), withQueryRequest(functions.QueryToJSON(dbFactory)))
	router.POST("/api/query/csv", auth.AuthMiddleware(), withQueryRequest(functions.QueryToCSV(dbFactory)))
	router.POST("/api/query/csv/param", auth.AuthMiddleware(), withQueryRequest(functions.QueryPositionalToCSV(dbFactory)))
	router.GET("/api/info", functions.InfoHandler(dbFactory))

	// 日志输出配置信息
	log.Printf("Service Port: %d", serviceConfig.Port)
	log.Printf("Service IdleTimeout: %d", serviceConfig.IdleTimeout)
	log.Printf("Service ReadTimeout: %d", serviceConfig.ReadTimeout)
	log.Printf("Service WriteTimeout: %d", serviceConfig.WriteTimeout)
	log.Printf("Service TrustedProxies: %s", serviceConfig.TrustedProxies)

	// 设置可信代理
	setupTrustedProxies(router, serviceConfig.TrustedProxies)

	// 创建HTTP服务器配置
	server := &http.Server{
		Addr:         fmt.Sprintf(":%d", serviceConfig.Port),
		Handler:      router,
		IdleTimeout:  time.Duration(serviceConfig.IdleTimeout) * time.Second,
		ReadTimeout:  time.Duration(serviceConfig.ReadTimeout) * time.Second,
		WriteTimeout: time.Duration(serviceConfig.WriteTimeout) * time.Second,
	}

	log.Printf("Starting HTTP server on port %d", serviceConfig.Port)
	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		log.Fatalf("Failed to start server: %v", err)
	}

}

// 参数绑定包装器
func withQueryRequest(handler func(c *gin.Context, req types.QueryRequest)) gin.HandlerFunc {
	return func(c *gin.Context) {
		var req types.QueryRequest
		if err := c.ShouldBindJSON(&req); err != nil {
			c.JSON(400, &types.QueryResult{
				Success: false,
				Error:   "Invalid request: " + err.Error(),
				Data:    nil,
			})
			return
		}

		handler(c, req)
	}
}

// 设置可信代理
func setupTrustedProxies(router *gin.Engine, trustedProxiesStr string) {
	if trustedProxiesStr == "" {
		setupTrustedProxiesRouter(router, nil)
		return
	}

	// 按逗号分割字符串，并去除空格
	proxies := strings.Split(trustedProxiesStr, ",")
	trimmedProxies := make([]string, 0, len(proxies))

	for _, proxy := range proxies {
		trimmed := strings.TrimSpace(proxy)
		if trimmed != "" {
			trimmedProxies = append(trimmedProxies, trimmed)
		}
	}

	if len(trimmedProxies) > 0 {
		setupTrustedProxiesRouter(router, trimmedProxies)
	} else {
		setupTrustedProxiesRouter(router, nil)
	}
}

func setupTrustedProxiesRouter(router *gin.Engine, trimmedProxies []string) {

	err := router.SetTrustedProxies(trimmedProxies)
	if err != nil {
		log.Printf("Warning: Failed to set trusted proxies: %v", err)
	} else {
		log.Printf("Trusted proxies set: %v", trimmedProxies)
	}

}

func setupGracefulShutdown(dbFactory *database.DBFactory) {
	signalCh := make(chan os.Signal, 1)
	signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)

	go func() {
		<-signalCh
		log.Println("\nReceived shutdown signal, closing database connection...")
		dbFactory.Close()
		log.Println("Database connection closed gracefully")
		os.Exit(0)
	}()
}