package main

import (
	"context"
	"embed"
	"io/fs"
	"log"
	"net/http"
	"strings"

	"git.x2erp.com/qdy/go-base/authbase"
	"git.x2erp.com/qdy/go-base/config"
	"git.x2erp.com/qdy/go-base/container"
	"git.x2erp.com/qdy/go-base/ctx"
	"git.x2erp.com/qdy/go-base/graceful"
	"git.x2erp.com/qdy/go-base/logger"
	"git.x2erp.com/qdy/go-base/model/request/configreq"
	"git.x2erp.com/qdy/go-base/model/response"
	"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"

	"git.x2erp.com/qdy/go-svc-configure/internal/service/admin"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/bootconfig"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/metamanagement"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/project"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/projectagent"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/projecttree"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/register"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/role"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/servicemanagement"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/skill"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/startup"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/svcstartup"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/tenant"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/token"
	"git.x2erp.com/qdy/go-svc-configure/internal/service/user"
	"git.x2erp.com/qdy/go-svc-configure/internal/tables"
	_ "git.x2erp.com/qdy/go-svc-configure/internal/tables" // 导入表定义包，触发 init() 函数
)

//go:embed web/dist
var frontendFS embed.FS

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

func main() {

	// 0. 初始化日志
	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)
	dbFactory.TestConnection()
	// 创建表
	creteTabel(dbFactory)

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

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

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

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

	// 注册前端静态文件服务
	frontendHandler := ServeFrontend()
	webServcie.GetRouter().Handle("/", frontendHandler)

	//启动服务
	webServcie.Run()

	//等待关闭
	graceful.WaitForShutdown(cfg.GetServiceConfig().ServiceName, ctr, webServcie.GetServer())

}

// 注册所有路由
func registerRoutes(ws *router.RouterService, dbFactory *database.DBFactory) {
	// 建立访问配置中心Token
	ws.POST("/api/create/config/token",
		func(tokenRequest *configreq.ConfigTokenRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[string], error) {
			return token.CreateConfigureToken(tokenRequest, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.TokenAuth).Desc("用户创建自身token").Register()

	// svc
	ws.POST("/api/delete/config/startup/{servicename}",
		func(servicename string, req *configreq.ConfigRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return svcstartup.DeleteSVCtartupConfig(servicename, req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Register()

	ws.POST("/api/create/config/startup/{servicename}",
		func(servicename string, req *configreq.ConfigRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return svcstartup.CreateStartupSVCConfig(servicename, req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.TokenAuth).Register()

	// service management
	ws.POST("/api/services/list",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]servicemanagement.ServiceInfo], error) {
			return servicemanagement.GetServices(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.TokenAuth).Desc("获取微服务列表").Register()

	ws.POST("/api/services/create",
		func(req *servicemanagement.CreateServiceRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return servicemanagement.CreateService(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.TokenAuth).Desc("创建微服务").Register()

	ws.POST("/api/services/configs",
		func(serviceName string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]servicemanagement.ServiceConfig], error) {
			return servicemanagement.GetServiceConfigs(ctx, dbFactory, serviceName, reqCtx), nil
		},
	).Use(authbase.TokenAuth).Desc("获取微服务配置项").Register()

	ws.POST("/api/services/configs/add",
		func(req *servicemanagement.AddServiceConfigRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return servicemanagement.AddServiceConfig(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.TokenAuth).Desc("为微服务添加配置项").Register()

	// startup
	ws.POST("/api/delete/config/startup",
		func(req *configreq.ConfigRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return startup.DeleteStartupConfig(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Register()

	ws.POST("/api/create/config/startup",
		func(req *configreq.ConfigRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return startup.CreateStartupConfig(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Register()

	// boot config
	ws.POST("/api/boot/configs",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]bootconfig.BootConfig], error) {
			return bootconfig.GetBootConfigs(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("获取boot配置项").Register()

	ws.POST("/api/boot/configs/search",
		func(keyword string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]bootconfig.BootConfig], error) {
			return bootconfig.SearchBootConfigs(ctx, dbFactory, keyword, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("搜索boot配置项").Register()

	//init
	ws.POST("/api/init/config/meta",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[map[string]interface{}], error) {
			return register.RegisterConfigMeta(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Register()

	// config meta management
	ws.POST("/api/config/meta/list",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]tables.ConfigMetaDB], error) {
			return metamanagement.ListConfigMeta(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询配置元信息列表").Register()

	ws.POST("/api/config/meta/search",
		func(configName, fieldName, yamlName string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]tables.ConfigMetaDB], error) {
			return metamanagement.SearchConfigMeta(ctx, dbFactory, configName, fieldName, yamlName, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("搜索配置元信息").Register()

	// project skill
	ws.POST("/api/create/config/project/skill",
		func(req *configreq.ProjectSkillRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return skill.CreateProjectSkill(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("创建项目Skill").Register()

	ws.POST("/api/update/config/project/skill/{skill_id}",
		func(skillID string, req *configreq.ProjectSkillRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return skill.UpdateProjectSkill(skillID, req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("更新项目Skill").Register()

	ws.POST("/api/delete/config/project/skill/{skill_id}",
		func(skillID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return skill.DeleteProjectSkill(skillID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("删除项目Skill").Register()

	ws.POST("/api/query/config/project/skill/{skill_id}",
		func(skillID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[tables.ProjectSkillDB], error) {
			return skill.GetProjectSkill(skillID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询项目Skill").Register()

	ws.POST("/api/query/config/project/skills",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]tables.ProjectSkillDB], error) {
			return skill.ListProjectSkills(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询项目Skill列表").Register()

	// project
	ws.POST("/api/create/config/project",
		func(req *configreq.ProjectRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return project.CreateProject(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("创建项目").Register()

	ws.POST("/api/update/config/project/{project_id}",
		func(projectID string, req *configreq.ProjectRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return project.UpdateProject(projectID, req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("更新项目").Register()

	ws.POST("/api/delete/config/project/{project_id}",
		func(projectID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return project.DeleteProject(projectID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("删除项目").Register()

	ws.POST("/api/query/config/project/{project_id}",
		func(projectID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[tables.ProjectDB], error) {
			return project.GetProject(projectID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询项目").Register()

	ws.POST("/api/query/config/projects",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]tables.ProjectDB], error) {
			return project.ListProjects(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询项目列表").Register()

	// project tree
	ws.GET("/api/projects/tree",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]projecttree.TreeNode], error) {
			return projecttree.GetProjectTree(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("获取项目树结构").Register()

	// project agent
	ws.POST("/api/create/config/project/agent",
		func(req *configreq.ProjectAgentRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return projectagent.CreateProjectAgent(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("创建项目Agent").Register()

	ws.POST("/api/update/config/project/agent/{agent_id}",
		func(agentID string, req *configreq.ProjectAgentRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return projectagent.UpdateProjectAgent(agentID, req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("更新项目Agent").Register()

	ws.POST("/api/delete/config/project/agent/{agent_id}",
		func(agentID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return projectagent.DeleteProjectAgent(agentID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("删除项目Agent").Register()

	ws.POST("/api/query/config/project/agent/{agent_id}",
		func(agentID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[tables.ProjectAgentDB], error) {
			return projectagent.GetProjectAgent(agentID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询项目Agent").Register()

	ws.POST("/api/query/config/project/agents",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]tables.ProjectAgentDB], error) {
			return projectagent.ListProjectAgents(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询项目Agent列表").Register()

	// tenant
	ws.POST("/api/create/config/tenant",
		func(req *configreq.TenantRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return tenant.CreateTenant(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("创建租户").Register()

	ws.POST("/api/update/config/tenant/{tenant_id}",
		func(tenantID string, req *configreq.TenantRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return tenant.UpdateTenant(tenantID, req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("更新租户").Register()

	ws.POST("/api/delete/config/tenant/{tenant_id}",
		func(tenantID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return tenant.DeleteTenant(tenantID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("删除租户").Register()

	ws.POST("/api/query/config/tenant/{tenant_id}",
		func(tenantID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[tables.TenantDB], error) {
			return tenant.GetTenant(tenantID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询租户").Register()

	ws.POST("/api/query/config/tenants",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]tables.TenantDB], error) {
			return tenant.ListTenants(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询租户列表").Register()

	// role
	ws.POST("/api/create/config/role",
		func(req *configreq.RoleRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return role.CreateRole(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("创建角色").Register()

	ws.POST("/api/update/config/role/{role_id}",
		func(roleID string, req *configreq.RoleRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return role.UpdateRole(roleID, req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("更新角色").Register()

	ws.POST("/api/delete/config/role/{role_id}",
		func(roleID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return role.DeleteRole(roleID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("删除角色").Register()

	ws.POST("/api/query/config/role/{role_id}",
		func(roleID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[tables.RoleDB], error) {
			return role.GetRole(roleID, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询角色").Register()

	ws.POST("/api/query/config/roles",
		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]tables.RoleDB], error) {
			return role.ListRoles(ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("查询角色列表").Register()

	// 用户注册（无需认证）
	ws.POST("/api/register/user",
		func(req *configreq.UserRegisterRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return user.RegisterUser(req, ctx, dbFactory, reqCtx), nil
		},
	).Desc("用户注册（需邀请码）").Register()

	// 用户登录（无需认证）
	ws.POST("/api/login/user",
		func(req *configreq.UserLoginRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[string], error) {
			return user.GetUserToken(req, ctx, dbFactory, reqCtx), nil
		},
	).Desc("用户登录（返回token）").Register()

	// 管理员登录（无需认证）
	ws.POST("/api/login/admin",
		func(req *configreq.UserLoginRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[bool], error) {
			return admin.LoginAdmin(req, ctx, reqCtx), nil
		},
	).Desc("管理员登录（验证配置文件凭据）").Register()

	// 创建租户管理员用户（BasicAuth认证）
	ws.POST("/api/create/tenant/admin",
		func(req *configreq.CreateTenantAdminRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[int64], error) {
			return user.CreateTenantAdmin(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.BasicAuth).Desc("创建租户管理员用户").Register()

	// 创建邀请码（TokenAuth认证）
	ws.POST("/api/create/invitation/code",
		func(req *configreq.CreateInvitationCodeRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[string], error) {
			return user.CreateInvitationCode(req, ctx, dbFactory, reqCtx), nil
		},
	).Use(authbase.TokenAuth).Desc("创建邀请码").Register()

}

func creteTabel(factory *database.DBFactory) {

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

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

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

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

// ServeFrontend 返回处理前端静态文件的服务处理器
func ServeFrontend() http.Handler {
	// 从嵌入的文件系统中获取 dist 子目录
	fsys, err := fs.Sub(frontendFS, "web/dist")
	if err != nil {
		// 如果失败，回退到空文件系统
		return http.FileServer(http.FS(frontendFS))
	}

	// 创建自定义文件服务器，处理 SPA 路由
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// 只处理 GET 和 HEAD 请求
		if r.Method != "GET" && r.Method != "HEAD" {
			// 对于非 GET/HEAD 请求，返回 404 让 API 路由处理
			http.NotFound(w, r)
			return
		}

		// API 路径不处理
		if strings.HasPrefix(r.URL.Path, "/api/") {
			http.NotFound(w, r)
			return
		}

		// 尝试从文件系统读取请求的文件
		filePath := strings.TrimPrefix(r.URL.Path, "/")
		if filePath == "" {
			filePath = "index.html"
		}

		// 检查文件是否存在
		_, err := fs.Stat(fsys, filePath)
		if err != nil {
			// 文件不存在，返回 index.html 用于 SPA 路由
			indexData, err := frontendFS.ReadFile("web/dist/index.html")
			if err != nil {
				http.Error(w, "Not Found", http.StatusNotFound)
				return
			}
			w.Header().Set("Content-Type", "text/html; charset=utf-8")
			w.Write(indexData)
			return
		}

		// 文件存在，正常提供
		http.FileServer(http.FS(fsys)).ServeHTTP(w, r)
	})
}