package main

import (
	"log"

	"git.x2erp.com/qdy/go-base/config"
	"git.x2erp.com/qdy/go-base/consul"
	"git.x2erp.com/qdy/go-base/container"
	"git.x2erp.com/qdy/go-base/webx"
	"git.x2erp.com/qdy/go-base/webx/health"
	"git.x2erp.com/qdy/go-base/webx/router"

	"git.x2erp.com/qdy/go-db/factory/database"

	"git.x2erp.com/qdy/go-base/ctx"
	"git.x2erp.com/qdy/go-base/logger"
	"git.x2erp.com/qdy/go-base/middleware"
)

var (
	appName    = "svc-ai"
	appVersion = "1"
)

// 定义结构体
type CreateUserRequest struct {
	Name  string `json:"name"`
	Email string `json:"email"`
	Age   int    `json:"age"`
}

type UserResponse struct {
	ID    string `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
	Data  []map[string]interface{}
}

func main() {

	//0.日志
	//logger.InitBootLog()
	logBootFactory := logger.InitBootLog()

	//1.获取配置文件
	cfg := config.GetConfig()
	cfg.SetAppName(appName)
	cfg.SetAppVersion(appVersion)

	//2.创建关闭容器
	ctr := container.NewContainer(cfg)

	//注册日志，实现自动关闭
	container.Reg(ctr, logBootFactory)

	//3.创建数据库工厂--如果需求
	dbFactory := container.Create(ctr, database.CreateDBFactory)

	// 赋值认证中间件参数
	middleware.JWTAuthMiddlewareInit(cfg)

	//测试数据库连接
	dbFactory.TestConnection()

	//得到webservice服务工厂
	webxFactory := webx.GetWebServiceFactory()

	//建立hhtpService服务
	webServcie, _ := webxFactory.CreateService(cfg.GetServiceConfig())

	//建立路由-api
	routerService := router.NewWebService(webServcie.GetRouter())

	//注册路由--api
	registerDorisRouter(routerService, dbFactory)

	// 注册健康检查-api
	health.RegisterConsulHealthCheck(routerService)

	//启动服务
	webServcie.Run()

	//启用运行日志
	container.Create(ctr, logger.InitRuntimeLogger)

	//注册到注册中心
	container.Create(ctr, consul.Register)
	//等待关闭
	webServcie.WaitForServiceShutdown(ctr)

	//consul.Register(service.serviceName, service.Ip, service.Port, b.Cfg.GetConsulConfig())
	//	service.NewWebService()

	// // 1. 初始化基础启动器
	// //boot := bootstraps.NewBootstrapper(serviceName, serviceVersion)

	// // 2. 初始化数据库（都在bootstraps包中）
	// dbBoot := dbstart.NewDBBootstrapper(boot.GetConfig())
	// dbBoot.Init()

	// agentDB := dbBoot.GetDBFactory("agent")
	// // 赋值认证中间件参数
	// middleware.JWTAuthMiddlewareInit(boot.GetConfig())

	// // 3. 启动服务
	// //boot.StartService("default")

	// router := boot.GetRouter("default")
	// // 3. 创建 WebService 并传入数据库接口
	// ws := webx.NewWebService(router)

	// // ✅ 为默认服务注册健康检查（端口 6060）
	// log.Println("注册默认服务健康检查...")
	// webx.RegisterDefaultHealthCheck(ws, "svc-ai")

	// //使用默认数据库
	// registerDefaultRouter(ws, dbBoot.GetDefaultDBFactory())

	// //启动第2个服务
	// routerDoris := boot.GetRouter("doris")
	// wsDoris := webx.NewWebService(routerDoris)
	// registerDorisRouter(wsDoris, agentDB)

	// //注册健康检查
	// webx.RegisterDefaultHealthCheck(wsDoris, "svc-doris")
	// // 6. 运行服务
	// boot.Run(dbBoot)
}

func registerDorisRouter(ws *router.RouterService, dbFactory *database.DBFactory) {
	// GET示例：路径参数绑定
	ws.GET("/app/users/{id}",
		func(id string, reqCtx *ctx.RequestContext) (UserResponse, error) {

			log.Print("ctx TenantID:", reqCtx.TenantID)
			// id 自动从路径绑定
			// 注意：webx版本没有自动注入dbFactory
			return getUserOracle(id, dbFactory) // 需要修改getUser函数以获取dbFactory
		},
	).Use(middleware.JWTAuthMiddleware).Register()

	// POST示例：Body参数绑定
	ws.POST("/app/users",
		func(req CreateUserRequest, reqCtx *ctx.RequestContext) (UserResponse, error) {
			log.Print("ctx TenantID:", reqCtx.TenantID)
			// req 自动从JSON Body绑定
			return createUser(req, nil) // 需要修改createUser函数以获取dbFactory
		},
	).Use(middleware.JWTAuthMiddleware).Register()

	// 您的业务路由
	ws.POST("/app/query/yaml",
		func() (interface{}, error) {
			return queryYaml(nil) // 需要修改queryYaml函数以获取dbFactory
		},
	).Use(middleware.JWTAuthMiddleware).Register()

	ws.POST("/app/init/config/template",
		func() (interface{}, error) {
			return initConfigTemplate(nil) // 需要修改initConfigTemplate函数以获取dbFactory
		},
	).Use(middleware.JWTAuthMiddleware).Register()

}

func registerDefaultRouter(ws *router.RouterService, dbFactory *database.DBFactory) {
	// GET示例：路径参数绑定
	ws.GET("/api/users/{id}",
		func(id string, reqCtx *ctx.RequestContext) (UserResponse, error) {

			log.Print("ctx TenantID:", reqCtx.TenantID)
			// id 自动从路径绑定
			// 注意：webx版本没有自动注入dbFactory
			return getUser(id, dbFactory) // 需要修改getUser函数以获取dbFactory
		},
	).Use(middleware.JWTAuthMiddleware).Register()

	// POST示例：Body参数绑定
	ws.POST("/api/users",
		func(req CreateUserRequest, reqCtx *ctx.RequestContext) (UserResponse, error) {
			log.Print("ctx TenantID:", reqCtx.TenantID)
			// req 自动从JSON Body绑定
			return createUser(req, nil) // 需要修改createUser函数以获取dbFactory
		},
	).Use(middleware.JWTAuthMiddleware).Register()

	// 您的业务路由
	ws.POST("/api/query/yaml",
		func() (interface{}, error) {
			return queryYaml(nil) // 需要修改queryYaml函数以获取dbFactory
		},
	).Use(middleware.JWTAuthMiddleware).Register()

	ws.POST("/api/init/config/template",
		func() (interface{}, error) {
			return initConfigTemplate(nil) // 需要修改initConfigTemplate函数以获取dbFactory
		},
	).Use(middleware.JWTAuthMiddleware).Register()

}

// 4. 创建路由器
// 首先需要创建标准库的ServeMux
//mux := http.NewServeMux()
//router := webx.NewRouter(boot.GetRouter())
//router := webx.NewWebService(mux)

// 5. 注册路由（Spring风格！）

func getUser(id string, dbFactory *database.DBFactory) (UserResponse, error) {
	if dbFactory != nil {
		dbFactory.TestConnection()
	}

	// 查询数据库...
	return UserResponse{
		ID:    id,
		Name:  "掌扇过去-AAAAA",
		Email: "zhangsan@example.com",
	}, nil
}

// 业务函数示例
func getUserOracle(id string, dbFactory *database.DBFactory) (UserResponse, error) {
	if dbFactory != nil {
		dbFactory.TestConnection()
	}

	sql, queryParams := getSQLWithPaginationSQL(0, 10)

	jsonData := dbFactory.QueryPositionalToJSON(sql, queryParams, nil)
	// 查询数据库...
	return UserResponse{
		ID:    id,
		Name:  "掌扇过去",
		Email: "zhangsan@example.com",
		Data:  jsonData.Data,
	}, nil
}

func createUser(req CreateUserRequest, dbFactory *database.DBFactory) (UserResponse, error) {
	logger.Debug("CreateUserRequest:%v", req)
	return UserResponse{
		ID:    "1",
		Name:  req.Name,
		Email: req.Email,
	}, nil
}

func queryYaml(dbFactory *database.DBFactory) (interface{}, error) {
	// 您的业务逻辑
	return map[string]interface{}{"message": "query yaml success"}, nil
}

func initConfigTemplate(dbFactory *database.DBFactory) (interface{}, error) {
	// 您的业务逻辑
	return map[string]interface{}{"message": "init config success"}, nil
}

// getSQLWithPagination 生成带分页的SQL语句（参数模式）
// 返回SQL语句和参数映射
func getSQLWithPaginationSQL(startRow, endRow int) (string, []interface{}) {
	sql := `SELECT
    CLOTHING_ID,
    CLOTHING_YEAR,
    CLOTHING_NAME

   FROM (
    SELECT a.*, ROWNUM as rn
    FROM (
        SELECT *
        FROM X6_STOCK_DEV.A3_CLOTHING 
     
        ORDER BY CLOTHING_ID
    ) a
    WHERE ROWNUM <= :1
)
WHERE rn > :2`

	// 创建参数映射
	params := []interface{}{
		endRow,
		startRow - 1, // WHERE rn > :start_row 所以是startRow-1
	}

	return sql, params
}