package routes

import (
	"ezops/internal/api/handlers"
	"ezops/internal/api/middleware"
	"ezops/internal/config"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
	"gorm.io/gorm"
	"time"
)

// Register 注册所有路由
func Register(r *gin.Engine, db *gorm.DB, log *zap.Logger, cfg *config.Config) {
	// API版本前缀
	api := r.Group("/api/v1")

	// 健康检查
	r.GET("/health", func(c *gin.Context) {
		c.JSON(200, gin.H{"status": "ok"})
	})

	// Agent 二进制下载 + 一键安装脚本（无需鉴权，方便 curl|bash）
	r.Static("/agent/bin", "./agent/bin")
	r.StaticFile("/agent/install.sh", "./agent/deploy/install.sh")
	r.StaticFile("/agent/aiops-agent-linux-amd64", "./agent/bin/aiops-agent-linux-amd64")
	r.StaticFile("/agent/aiops-agent-linux-arm64", "./agent/bin/aiops-agent-linux-arm64")
	r.StaticFile("/agent/aiops-agent-darwin-arm64", "./agent/bin/aiops-agent-darwin-arm64") // macOS Apple Silicon // Logan.Li
	r.GET("/agent/arch", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"version": "1.0.0",
			"downloads": gin.H{
				"linux-amd64":  "/agent/aiops-agent-linux-amd64",
				"linux-arm64":  "/agent/aiops-agent-linux-arm64",
				"darwin-arm64": "/agent/aiops-agent-darwin-arm64",
			},
			"install": "curl -fsSL http://<server>:8080/agent/install.sh | sudo bash -s -- --server http://<server>:8080 --token <token>",
		})
	})

	// WebSocket终端 (token via query param)
	webShellHandler := handlers.NewWebShellHandler(db)
	r.GET("/ws/terminal", webShellHandler.Terminal)

	// 公开路由
	authHandler := handlers.NewUserHandler(db, cfg)
	api.POST("/auth/login", authHandler.Login)
	api.POST("/auth/register", authHandler.Register)

	// 需要认证的路由
	authorized := api.Group("")
	authorized.Use(middleware.JWTAuth(&cfg.JWT))

	// 用户路由
	user := authorized.Group("/user")
	{
		user.GET("/profile", authHandler.GetProfile)
		user.PUT("/profile", authHandler.UpdateProfile)
		user.POST("/change-password", authHandler.ChangePassword)
		user.GET("/roles", authHandler.ListRoles)
	}

	// 管理员路由
	admin := authorized.Group("/admin")
	admin.Use(middleware.AdminAuth())
	{
		admin.GET("/users", authHandler.ListUsers)
		admin.GET("/users/:id", authHandler.GetUser)
		admin.POST("/users", authHandler.CreateUser)
		admin.PUT("/users/:id", authHandler.UpdateUser)
		admin.DELETE("/users/:id", authHandler.DeleteUser)
		admin.POST("/users/batch-import", authHandler.BatchImportUsers)
		admin.GET("/users/import-template", authHandler.ImportTemplate)

		// 角色管理路由 // Logan.Li
		admin.GET("/roles", authHandler.ListRoles)
		admin.POST("/roles", authHandler.CreateRole)
		admin.PUT("/roles/:id", authHandler.UpdateRole)
		admin.DELETE("/roles/:id", authHandler.DeleteRole)

		// 权限列表（供角色权限选择）
		admin.GET("/permissions", authHandler.ListPermissions)
	}

	// LDAP 配置路由
	ldapHandler := handlers.NewLDAPHandler(db)
	ldapGroup := authorized.Group("/admin/ldap-config")
	ldapGroup.Use(middleware.AdminAuth())
	{
		ldapGroup.GET("", ldapHandler.GetLDAPConfig)
		ldapGroup.PUT("", ldapHandler.UpdateLDAPConfig)
		ldapGroup.POST("/test", ldapHandler.TestLDAPConnection)
		ldapGroup.POST("/users", ldapHandler.ListLDAPUsers)
		ldapGroup.POST("/import", ldapHandler.BatchImportLDAP)
		ldapGroup.POST("/ou-list", ldapHandler.ListLDAPOUs)
		ldapGroup.POST("/create-ou", ldapHandler.CreateLDAPOU)
		ldapGroup.POST("/create-user", ldapHandler.CreateLDAPUser)
		ldapGroup.POST("/delete-user", ldapHandler.DeleteLDAPUser)
		ldapGroup.POST("/update-user", ldapHandler.UpdateLDAPUser)
	}

	// 仪表盘路由
	dashboardHandler := handlers.NewDashboardHandler(db)
	dashboard := authorized.Group("/dashboard")
	{
		dashboard.GET("/stats", dashboardHandler.GetStats)
		dashboard.GET("/recent-alerts", dashboardHandler.GetRecentAlerts)
		dashboard.GET("/recent-releases", dashboardHandler.GetRecentReleases)
		dashboard.GET("/metrics", dashboardHandler.GetMetrics)
	}

	// 服务器路由
	serverHandler := handlers.NewServerHandler(db)
	servers := authorized.Group("/servers")
	{
		servers.GET("", serverHandler.ListServers)
		servers.GET("/stats", serverHandler.GetServerStats)
		servers.GET("/:id", serverHandler.GetServer)
		servers.POST("", serverHandler.CreateServer)
		servers.PUT("/:id", serverHandler.UpdateServer)
		servers.DELETE("/:id", serverHandler.DeleteServer)
		servers.POST("/batch-delete", serverHandler.BatchDeleteServers)
		servers.POST("/batch", serverHandler.BatchCreateServers)
	}

	// 云账号路由
	cloudAccountHandler := handlers.NewCloudAccountHandler(db)
	cloudAccounts := authorized.Group("/cloud-accounts")
	{
		cloudAccounts.GET("", cloudAccountHandler.ListCloudAccounts)
		cloudAccounts.POST("", cloudAccountHandler.CreateCloudAccount)
		cloudAccounts.PUT("/:id", cloudAccountHandler.UpdateCloudAccount)
		cloudAccounts.DELETE("/:id", cloudAccountHandler.DeleteCloudAccount)
	}

	// 域名路由
	domainHandler := handlers.NewDomainHandler(db)
	domains := authorized.Group("/domains")
	{
		domains.GET("", domainHandler.ListDomains)
		domains.POST("", domainHandler.CreateDomain)
		domains.PUT("/:id", domainHandler.UpdateDomain)
		domains.DELETE("/:id", domainHandler.DeleteDomain)
	}

	// 云平台路由
	platformHandler := handlers.NewPlatformHandler(db)
	platforms := authorized.Group("/platforms")
	{
		platforms.GET("", platformHandler.ListPlatforms)
		platforms.POST("", platformHandler.CreatePlatform)
		platforms.PUT("/:id", platformHandler.UpdatePlatform)
		platforms.DELETE("/:id", platformHandler.DeletePlatform)
	}

	// 区域路由
	regionHandler := handlers.NewRegionHandler(db)
	regions := authorized.Group("/regions")
	{
		regions.GET("", regionHandler.ListRegions)
		regions.POST("", regionHandler.CreateRegion)
		regions.PUT("/:id", regionHandler.UpdateRegion)
		regions.DELETE("/batch-delete", regionHandler.BatchDeleteRegions) // Logan.Li
		regions.DELETE("/:id", regionHandler.DeleteRegion)
	}

	// 云账单路由
	billingHandler := handlers.NewBillingHandler(db)
	billings := authorized.Group("/cloud-billings")
	{
		billings.GET("", billingHandler.ListBillings)
		billings.POST("", billingHandler.CreateBilling)
		billings.POST("/batch", billingHandler.BatchCreateBillings)
		billings.DELETE("/:id", billingHandler.DeleteBilling)
		billings.GET("/stats", billingHandler.GetBillingStats)
		billings.GET("/providers", billingHandler.GetProviderOptions)
	}
	billingAlerts := authorized.Group("/billing-alerts")
	{
		billingAlerts.GET("", billingHandler.ListAlertRules)
		billingAlerts.POST("", billingHandler.CreateAlertRule)
		billingAlerts.PUT("/:id", billingHandler.UpdateAlertRule)
		billingAlerts.DELETE("/:id", billingHandler.DeleteAlertRule)
		billingAlerts.POST("/:id/toggle", billingHandler.ToggleAlertRule)
	}

	// 资源模型路由
	resourceModelHandler := handlers.NewResourceModelHandler(db)
	resourceModels := authorized.Group("/resource-models")
	{
		resourceModels.GET("", resourceModelHandler.ListResourceModels)
		resourceModels.POST("", resourceModelHandler.CreateResourceModel)
		resourceModels.PUT("/:id", resourceModelHandler.UpdateResourceModel)
		resourceModels.DELETE("/:id", resourceModelHandler.DeleteResourceModel)
	}

	// K8s集群路由
	k8sHandler := handlers.NewK8sHandler(db)
	clusters := authorized.Group("/k8s-clusters")
	{
		clusters.GET("", k8sHandler.ListClusters)
		clusters.GET("/:id", k8sHandler.GetCluster)
		clusters.POST("", k8sHandler.CreateCluster)
		clusters.PUT("/:id", k8sHandler.UpdateCluster)
		clusters.DELETE("/:id", k8sHandler.DeleteCluster)
		clusters.GET("/:id/nodes", k8sHandler.ListNodes)
		clusters.GET("/:id/pods", k8sHandler.ListPods)
		clusters.GET("/:id/deployments", k8sHandler.ListDeployments)
		clusters.GET("/:id/services", k8sHandler.ListServices)
		clusters.GET("/:id/ingresses", k8sHandler.ListIngresses)
		clusters.GET("/:id/topology", k8sHandler.GetTopology)   // 获取拓扑布局 // Logan.Li
		clusters.PUT("/:id/topology", k8sHandler.SaveTopology)  // 保存拓扑布局 // Logan.Li
	}

	// 告警路由
	alertHandler := handlers.NewAlertHandler(db)
	alerts := authorized.Group("/alerts")
	{
		alerts.GET("", alertHandler.ListAlerts)
		alerts.GET("/rules", alertHandler.ListRules)
		alerts.POST("/rules", alertHandler.CreateRule)
		alerts.PUT("/rules/:id", alertHandler.UpdateRule)
		alerts.DELETE("/rules/batch-delete", alertHandler.BatchDeleteRules)
		alerts.DELETE("/rules/:id", alertHandler.DeleteRule)
		alerts.POST("/rules/:id/toggle", alertHandler.ToggleRule)
		alerts.POST("/:id/ack", alertHandler.AcknowledgeAlert)
		alerts.GET("/notify-channels", alertHandler.ListNotifyChannels)
		alerts.POST("/notify-channels", alertHandler.CreateNotifyChannel)
		alerts.PUT("/notify-channels/:id", alertHandler.UpdateNotifyChannel)
		alerts.DELETE("/notify-channels/:id", alertHandler.DeleteNotifyChannel)
		alerts.POST("/notify-channels/:id/test", alertHandler.TestNotifyChannel)
	}

	// 流水线路由
	pipelineHandler := handlers.NewPipelineHandler(db)
	pipelines := authorized.Group("/pipelines")
	{
		pipelines.GET("", pipelineHandler.ListPipelines)
		pipelines.POST("", pipelineHandler.CreatePipeline)
		pipelines.GET("/:id", pipelineHandler.GetPipeline)
		pipelines.PUT("/:id", pipelineHandler.UpdatePipeline)
		pipelines.DELETE("/:id", pipelineHandler.DeletePipeline)
		pipelines.POST("/:id/trigger", pipelineHandler.TriggerPipeline)
		pipelines.GET("/:id/runs", pipelineHandler.ListRuns)
	}

	// 应用发布路由
	releases := authorized.Group("/releases")
	{
		releases.GET("", pipelineHandler.ListReleases)
		releases.POST("", pipelineHandler.CreateRelease)
		releases.POST("/:id/approve", pipelineHandler.ApproveRelease)
		releases.POST("/:id/reject", pipelineHandler.RejectRelease)   // 驳回发布 // Logan.Li
		releases.POST("/:id/deploy", pipelineHandler.DeployRelease)
		releases.POST("/:id/rollback", pipelineHandler.RollbackRelease)
	}

	// 自动化运维路由
	automationHandler := handlers.NewAutomationHandler(db)
	cronJobs := authorized.Group("/cron-jobs")
	{
		cronJobs.GET("", automationHandler.ListCronJobs)
		cronJobs.POST("", automationHandler.CreateCronJob)
		cronJobs.GET("/:id", automationHandler.GetCronJob)
		cronJobs.PUT("/:id", automationHandler.UpdateCronJob)
		cronJobs.DELETE("/batch-delete", automationHandler.BatchDeleteCronJobs)
		cronJobs.DELETE("/:id", automationHandler.DeleteCronJob)
		cronJobs.POST("/:id/toggle", automationHandler.ToggleCronJob)
		cronJobs.POST("/:id/execute", automationHandler.ExecuteCronJob)
	}

	scripts := authorized.Group("/scripts")
	{
		scripts.GET("", automationHandler.ListScripts)
		scripts.POST("", automationHandler.CreateScript)
		scripts.GET("/:id", automationHandler.GetScript)
		scripts.PUT("/:id", automationHandler.UpdateScript)
		scripts.POST("/batch-delete", automationHandler.BatchDeleteScripts)
		scripts.DELETE("/:id", automationHandler.DeleteScript)
		scripts.POST("/:id/execute", automationHandler.ExecuteScript)
	}

	playbooks := authorized.Group("/playbooks")
	{
		playbooks.GET("", automationHandler.ListPlaybooks)
		playbooks.POST("", automationHandler.CreatePlaybook)
		playbooks.GET("/:id", automationHandler.GetPlaybook)
		playbooks.PUT("/:id", automationHandler.UpdatePlaybook)
		playbooks.DELETE("/:id", automationHandler.DeletePlaybook)
		playbooks.POST("/:id/execute", automationHandler.ExecutePlaybook)
	}

	// 任务执行记录（脚本/定时任务执行历史）
	authorized.GET("/task-executions", automationHandler.ListExecutions)

	// Ansible 自动化路由 // Logan.Li
	ansibleHandler := handlers.NewAnsibleHandler(db)
	ansible := authorized.Group("/ansible")
	{
		ansible.GET("/playbooks", ansibleHandler.ListPlaybooks)
		ansible.POST("/playbooks", ansibleHandler.CreatePlaybook)
		ansible.GET("/playbooks/:id", ansibleHandler.GetPlaybook)
		ansible.PUT("/playbooks/:id", ansibleHandler.UpdatePlaybook)
		ansible.DELETE("/playbooks/:id", ansibleHandler.DeletePlaybook)
		ansible.DELETE("/playbooks/batch-delete", ansibleHandler.BatchDeletePlaybooks)
		ansible.POST("/playbooks/:id/execute", ansibleHandler.ExecutePlaybook)

		ansible.GET("/jobs", ansibleHandler.ListJobs)
		ansible.GET("/jobs/:id", ansibleHandler.GetJob)

		ansible.GET("/inventories", ansibleHandler.ListInventories)
		ansible.POST("/inventories", ansibleHandler.CreateInventory)
		ansible.PUT("/inventories/:id", ansibleHandler.UpdateInventory)
		ansible.DELETE("/inventories/:id", ansibleHandler.DeleteInventory)
	}

	// 日志监控路由 // Logan.Li
	logHandler := handlers.NewLogHandler(db)
	logs := authorized.Group("/logs")
	{
		logs.GET("", logHandler.QueryLogs)
		logs.GET("/sources", logHandler.ListSources)
		logs.POST("/sources", logHandler.CreateSource)
		logs.DELETE("/sources/:id", logHandler.DeleteSource)
	}

	// 审批流程路由
	approvalHandler := handlers.NewApprovalHandler(db)
	approvals := authorized.Group("/approvals")
	{
		approvals.GET("/templates", approvalHandler.ListTemplates)
		approvals.POST("/templates", approvalHandler.CreateTemplate)
		approvals.GET("/templates/:id", approvalHandler.GetTemplate)
		approvals.PUT("/templates/:id", approvalHandler.UpdateTemplate)
		approvals.DELETE("/templates/:id", approvalHandler.DeleteTemplate)

		approvals.GET("/processes", approvalHandler.ListProcesses)
		approvals.POST("/processes", approvalHandler.CreateProcess)
		approvals.GET("/processes/:id", approvalHandler.GetProcess)
		approvals.POST("/processes/:id/approve", approvalHandler.ApproveProcess)
		approvals.POST("/processes/:id/reject", approvalHandler.RejectProcess)
	}

	// 导航路由
	navHandler := handlers.NewNavigationHandler(db)
	navigations := authorized.Group("/navigations")
	{
		navigations.GET("/groups", navHandler.ListGroups)
		navigations.POST("/groups", navHandler.CreateGroup)
		navigations.PUT("/groups/:id", navHandler.UpdateGroup)
		navigations.DELETE("/groups/:id", navHandler.DeleteGroup)

		navigations.GET("/links", navHandler.ListLinks)
		navigations.POST("/links", navHandler.CreateLink)
		navigations.PUT("/links/:id", navHandler.UpdateLink)
		navigations.DELETE("/links/:id", navHandler.DeleteLink)
		navigations.POST("/links/:id/favorite", navHandler.ToggleFavorite)
	}

	// 审计日志路由
	auditHandler := handlers.NewAuditHandler(db)
	audit := authorized.Group("/audit")
	{
		audit.GET("/logs", auditHandler.ListAuditLogs)
		audit.GET("/logs/:id", auditHandler.GetAuditLogDetail)
		audit.GET("/modules", auditHandler.GetAuditModules)
		audit.GET("/actions", auditHandler.GetAuditActions)
		audit.GET("/logs/export", auditHandler.ExportAuditLogs)
		audit.GET("/statistics", auditHandler.GetAuditStatistics)
		audit.POST("/logs/clear", auditHandler.ClearAuditLogs)
	}

	// SQL审计路由 // Logan.Li
	sqlAuditHandler := handlers.NewSQLAuditHandler(db)
	sqlAudit := authorized.Group("/sql-audit")
	{
		sqlAudit.GET("/records", sqlAuditHandler.ListRecords)
		sqlAudit.GET("/records/:id", sqlAuditHandler.GetRecord)
		sqlAudit.POST("/analyze", sqlAuditHandler.AnalyzeSQL)
		sqlAudit.POST("/records/:id/approve", sqlAuditHandler.ApproveRecord)
		sqlAudit.POST("/records/:id/reject", sqlAuditHandler.RejectRecord)
		sqlAudit.POST("/records/:id/execute", sqlAuditHandler.ExecuteRecord)
		sqlAudit.DELETE("/records/:id", sqlAuditHandler.DeleteRecord)
		sqlAudit.GET("/rules", sqlAuditHandler.ListRules)
		sqlAudit.POST("/rules", sqlAuditHandler.CreateRule)
		sqlAudit.PUT("/rules/:id", sqlAuditHandler.UpdateRule)
		sqlAudit.DELETE("/rules/:id", sqlAuditHandler.DeleteRule)
		sqlAudit.POST("/rules/:id/toggle", sqlAuditHandler.ToggleRule)
	}

	// Agent 上报路由（无需 JWT）
	agentHandler := handlers.NewAgentHandler(db)
	taskHandler := handlers.NewAgentTaskHandler(db)
	agentGroup := api.Group("/agent")
	{
		agentGroup.POST("/report", agentHandler.ReceiveReport)
		agentGroup.GET("/tasks/poll", taskHandler.PollTasks)
		agentGroup.POST("/tasks/:task_id/result", taskHandler.SubmitResult)
	}
	// Agent 数据查询 + 任务管理（需要 JWT）
	agentQuery := authorized.Group("/agent")
	{
		agentQuery.GET("/latest", agentHandler.GetLatestReports)
		agentQuery.GET("/history/:hostname", agentHandler.GetHostHistory)

		// 远程任务
		agentQuery.POST("/tasks", taskHandler.CreateTask)
		agentQuery.GET("/tasks", taskHandler.ListTasks)
		agentQuery.GET("/tasks/:id", taskHandler.GetTask)

		// 告警规则
		agentQuery.GET("/rules", taskHandler.ListRules)
		agentQuery.POST("/rules", taskHandler.CreateRule)
		agentQuery.PUT("/rules/:id", taskHandler.UpdateRule)
		agentQuery.DELETE("/rules/:id", taskHandler.DeleteRule)

		// 告警事件
		agentQuery.GET("/alerts", taskHandler.ListAlerts)
		agentQuery.POST("/alerts/:id/resolve", taskHandler.ResolveAlert)
	}

	// 启动告警引擎（每 30 秒检查一次）
	alertEngine := handlers.NewAlertEngine(db)
	go func() {
		ticker := time.NewTicker(30 * time.Second)
		defer ticker.Stop()
		for range ticker.C {
			alertEngine.Check()
		}
	}()
}