package main

import (
	"fmt"
	"log"
	"net/http"

	"git.x2erp.com/qdy/go-svc-mcp/internal/handler"
	"git.x2erp.com/qdy/go-svc-mcp/internal/mcp"

	_ "git.x2erp.com/qdy/go-svc-mcp/internal/tools/commons" // 触发工具自动注册
	_ "git.x2erp.com/qdy/go-svc-mcp/internal/tools/dbs"     // 触发工具自动注册

	"git.x2erp.com/qdy/go-base/authbase"
	"git.x2erp.com/qdy/go-base/config"
	"git.x2erp.com/qdy/go-base/config/core"
	"git.x2erp.com/qdy/go-base/config/subconfigs"
	"git.x2erp.com/qdy/go-base/container"
	"git.x2erp.com/qdy/go-base/graceful"
	"git.x2erp.com/qdy/go-base/logger"
	"git.x2erp.com/qdy/go-base/webx"
	"git.x2erp.com/qdy/go-base/webx/router"

	"git.x2erp.com/qdy/go-db/factory/database"
	"git.x2erp.com/qdy/go-db/sqldef"
	mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"

	_ "git.x2erp.com/qdy/go-svc-mcp/internal/tables" // 导入表定义包，触发 init() 函数
)

// 数据库配置键名常量（yaml配置键名）
const (
	// BusinessDBKey 业务数据库键名
	BusinessDBKey = "business"
	// WarehouseDBKey 仓库数据库键名
	WarehouseDBKey = "warehouse"
)

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

func validateDbsConfigKeys() error {
	// 获取 dbs 配置
	dbsConfig := core.GetRegisteredConfig("dbs")
	if dbsConfig == nil {
		log.Println("多数据库配置为空，数据库相关工具无法使用")
		log.Println("配置要求说明：")
		log.Println("1. 在配置文件中添加 dbs 配置节")
		log.Println("2. 必须同时配置 'business' 和 'warehouse' 两个数据库")
		log.Println("3. 示例配置：")
		log.Println("   databases:")
		log.Println("     business:")
		log.Println("       host: \"localhost\"")
		log.Println("       port: 3306")
		log.Println("     warehouse:")
		log.Println("       host: \"localhost\"")
		log.Println("       port: 3307")
		return nil // 空配置允许继续执行
	}

	dbs, ok := dbsConfig.(*subconfigs.DbsConfig)
	if !ok {
		return fmt.Errorf("dbs配置类型错误")
	}

	if len(dbs.Databases) == 0 {
		log.Println("多数据库配置为空，数据库相关工具无法使用")
		log.Println("配置要求说明：")
		log.Println("1. 在配置文件中添加 dbs 配置节")
		log.Println("2. 必须同时配置 'business' 和 'warehouse' 两个数据库")
		log.Println("3. 示例配置：")
		log.Println("   databases:")
		log.Println("     business:")
		log.Println("       host: \"localhost\"")
		log.Println("       port: 3306")
		log.Println("     warehouse:")
		log.Println("       host: \"localhost\"")
		log.Println("       port: 3307")
		return nil // 空配置允许继续执行
	}

	// 检查配置的键名必须是 business 和 warehouse
	hasBusiness := false
	hasWarehouse := false

	for key := range dbs.Databases {
		switch key {
		case BusinessDBKey:
			hasBusiness = true
		case WarehouseDBKey:
			hasWarehouse = true
		default:
			return fmt.Errorf("数据库配置键名 '%s' 错误，只允许配置 '%s' 和 '%s'", key, BusinessDBKey, WarehouseDBKey)
		}
	}

	// 检查是否同时包含 business 和 warehouse
	if !hasBusiness || !hasWarehouse {
		return fmt.Errorf("数据库配置必须同时包含 '%s' 和 '%s' 两个数据库", BusinessDBKey, WarehouseDBKey)
	}

	// 检查是否有额外的数据库配置
	if len(dbs.Databases) > 2 {
		return fmt.Errorf("数据库配置只能包含 '%s' 和 '%s' 两个数据库，不能有其他数据库配置", BusinessDBKey, WarehouseDBKey)
	}

	log.Printf("多数据库配置键名验证通过，包含 %s 和 %s 数据库", BusinessDBKey, WarehouseDBKey)
	return nil
}

func main() {
	// 0. 初始化日志
	logBootFactory := logger.InitBootLog()

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

	// 验证多数据库配置键名
	if err := validateDbsConfigKeys(); err != nil {
		log.Fatalf("多数据库配置验证失败: %v", err)
	}

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

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

	// 3. 创建数据库工厂
	dbFactory := container.Create(ctr, database.CreateDBFactory)
	dbFactory.TestConnection()

	//建立多数据库
	dbs := container.Create(ctr, database.CreateDBSFactory)
	// 创建表
	creteTabel(dbFactory)

	// 创建mongodb
	//mongoDBFactory := container.Create(ctr, mongodb.CreateFactory)
	//mongoDBFactory.TestConnection()

	// 创建mcpservice
	mcpServer := createMcpService(cfg, dbFactory, dbs)

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

	//建立httpservice
	webxService := createMHttpService(cfg, dbFactory)

	//等待关闭
	graceful.WaitForShutdown(cfg.GetServiceConfig().ServiceName, ctr, mcpServer.GetHTTPServer(), webxService.GetServer())
}

// 创建httpService
func createMHttpService(cfg config.IConfig, dbFactory *database.DBFactory) *webx.WebService {
	//得到webservice服务工厂
	webxFactory := webx.GetWebServiceFactory()

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

	//建立路由-api
	routerService := router.NewWebService(webServcie.GetRouter())
	//注册路由--api
	handler.RegisterRouter(routerService, dbFactory)

	//启动服务
	webServcie.Run()
	return webServcie
}

// createMcpService 创建mcpService
func createMcpService(cfg config.IConfig, dbFactory *database.DBFactory, dbs *database.DBSFactory) *mcp.Server {

	// 4. 创建基础请求上下文（可从配置或认证中提取）
	//baseCtx := &ctx.RequestContext{
	//	TenantID: "default-tenant", // 实际应从认证中间件获取
	//}

	// 5. 创建 MCP 服务器
	mcpServer, err := mcp.NewServer(mcp.Config{
		Name:        appName,
		Version:     appVersion,
		Description: "MCP 工具服务，提供自动注册发现和依赖注入",
		DBFactory:   dbFactory,
		DBSFactory:  dbs,
		Port:        cfg.GetMcpServiceConfig().Port,
		ServiceName: cfg.GetMcpServiceConfig().ServiceName,
	})

	if err != nil {
		log.Fatalf("Failed to create MCP server: %v", err)
	}
	log.Printf("MCP server created with tools registered")

	// 6. 获取 SDK 服务器实例
	sdkServer := mcpServer.GetSDKServer()

	mcpHandler := mcpsdk.NewStreamableHTTPHandler(func(req *http.Request) *mcpsdk.Server {
		return sdkServer
	}, nil)
	// 包装验证中间件
	//handler := auth.AuthMiddlewareMcp(mcpHandler, dbFactory)
	handler := authbase.TokenAuth(mcpHandler)

	sdkServer.AddReceivingMiddleware()
	mcpServer.Run(handler)

	return mcpServer
}

func creteTabel(factory *database.DBFactory) {

	// 获取数据库连接和类型
	db := factory.GetDB()
	dbType := factory.GetDBType()

	// 创建表同步器
	syncer, err := sqldef.NewTableSyncer(db, dbType)
	if err != nil {
		log.Printf("创建 - 建立器失败: %v", err)
		return
	}

	// 创建表
	if err := syncer.CreateTables(); err != nil {
		log.Printf("建表失败: %v", err)
		return
	}

	log.Println("数据库表建立完成！")
}