package app

import (
	"io/fs"
	"net/http"
	"os"

	"next-terminal/server/api"
	"next-terminal/server/api/worker"
	mw "next-terminal/server/app/middleware"
	"next-terminal/server/config"
	"next-terminal/server/log"
	"next-terminal/server/resource"

	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
)

func getFS(useOS bool) fs.FS {
	if useOS {
		log.Debug("using live mode")
		return os.DirFS("web/build")
	}

	log.Debug("using embed mode")
	fsys, err := fs.Sub(resource.Resource, "build")
	if err != nil {
		panic(err)
	}

	return fsys
}

func WrapHandler(h http.Handler) echo.HandlerFunc {
	return func(c echo.Context) error {
		c.Response().Header().Set("Cache-Control", `public, max-age=31536000`)
		h.ServeHTTP(c.Response(), c.Request())
		return nil
	}
}

func setupRoutes() *echo.Echo {

	e := echo.New()
	e.HideBanner = true
	//e.Logger = log.GetEchoLogger()
	//e.Use(log.Hook())

	fsys := getFS(config.GlobalCfg.Debug)
	fileServer := http.FileServer(http.FS(fsys))
	handler := WrapHandler(fileServer)
	e.GET("/", handler)
	e.GET("/branding", api.Branding)
	e.GET("/logo", api.Logo)
	e.GET("/favicon.ico", handler)
	e.GET("/static/*", handler)

	e.Use(middleware.Recover())
	e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
		Skipper:      middleware.DefaultSkipper,
		AllowOrigins: []string{"*"},
		AllowMethods: []string{http.MethodGet, http.MethodHead, http.MethodPut, http.MethodPatch, http.MethodPost, http.MethodDelete},
	}))
	e.Use(mw.ErrorHandler)
	e.Use(mw.TcpWall)

	setupApi := new(api.SetupApi)
	accountApi := new(api.AccountApi)

	apiGroup := e.Group("/api")
	{
		apiGroup.GET("/branding", api.Branding)
		apiGroup.GET("/logo", api.Logo)

		adminGroup := apiGroup.Group("/admin")
		{
			adminGroup.POST("/login", accountApi.LoginEndpoint)
			adminGroup.GET("/setup-status", setupApi.GetSetupStatusEndpoint)
			adminGroup.POST("/setup-user", setupApi.SetupUserEndpoint)
		}
	}

	e.Use(mw.Auth)
	//e.Use(RBAC)
	e.Use(middleware.Gzip())

	apiGroup = e.Group("/api")
	{
		AgentGatewayApi := new(api.AgentGatewayApi)

		apiGroup.GET("/branding", api.Branding)
		apiGroup.GET("/logo", api.Logo)
		apiGroup.GET("/agent/version", AgentGatewayApi.VersionEndpoint)

		adminGroup := apiGroup.Group("/admin")

		PortalApi := new(api.PortalApi)
		AccessSettingApi := new(api.AccessSettingApi)
		webTerminalApi := new(api.WebTerminalApi)
		FileSystemApi := new(api.FileSystemApi)

		{

			guacamoleApi := new(api.GuacamoleApi)
			UserApi := new(api.UserApi)
			UserGroupApi := new(api.UserGroupApi)
			AssetApi := new(api.AssetApi)
			CommandApi := new(api.CommandApi)
			CredentialApi := new(api.CredentialApi)
			SessionApi := new(api.SessionApi)
			LoginLogApi := new(api.LoginLogApi)
			PropertyApi := new(api.PropertyApi)
			LogoApi := new(api.LogoApi)
			OverviewApi := new(api.OverviewApi)
			JobApi := new(api.JobApi)
			SecurityApi := new(api.SecurityApi)
			StorageApi := new(api.StorageApi)
			StrategyApi := new(api.StrategyApi)
			AccessGatewayApi := new(api.AccessGatewayApi)
			BackupApi := new(api.BackupApi)
			TenantApi := new(api.TenantApi)
			RoleApi := new(api.RoleApi)
			LoginPolicyApi := new(api.LoginPolicyApi)
			StorageLogApi := new(api.StorageLogApi)
			AuthorisedApi := new(api.AuthorisedApi)
			DashboardApi := new(api.DashboardApi)
			DepartmentApi := new(api.DepartmentApi)
			SnippetApi := new(api.SnippetApi)
			CommandFilterApi := new(api.CommandFilterApi)
			DatabaseAssetApi := new(api.DatabaseAssetApi)
			AssetGroupApi := new(api.AssetGroupApi)
			SshGatewayApi := new(api.SshGatewayApi)
			GatewayGroupApi := new(api.GatewayGroupApi)
			WebsiteApi := new(api.WebsiteApi)
			CertificateApi := new(api.CertificateApi)
			ToolsApi := new(api.ToolsApi)

			adminGroup.GET("/login-status", setupApi.LoginStatusEndpoint)
			adminGroup.POST("/validate-totp", setupApi.ValidateTOTPEndpoint)
			adminGroup.GET("/account/password-policy", setupApi.PasswordPolicyEndpoint)
			adminGroup.GET("/captcha", setupApi.GetCaptchaEndpoint)

			dashboard := adminGroup.Group("/dashboard")
			{
				dashboard.GET("/time-counter", DashboardApi.GetTimeCounterEndpoint)
				dashboard.GET("/v2/date-counter", DashboardApi.GetDateCounterV2Endpoint)
				dashboard.GET("/asset-types", DashboardApi.GetAssetTypesEndpoint)
			}

			departments := adminGroup.Group("/departments")
			{
				departments.GET("", DepartmentApi.AllEndpoint)
				departments.GET("/paging", DepartmentApi.PagingEndpoint)
				departments.POST("", DepartmentApi.CreateEndpoint)
				departments.PUT("/:id", DepartmentApi.UpdateEndpoint)
				departments.DELETE("/:id", DepartmentApi.DeleteEndpoint)
				departments.GET("/:id", DepartmentApi.GetEndpoint)
				departments.GET("/tree", DepartmentApi.GetTreeEndpoint)
				departments.GET("/:id/users", DepartmentApi.GetDepartmentUsersEndpoint)
				departments.POST("/:id/users", DepartmentApi.SetDepartmentUsersEndpoint)
				departments.POST("/:id/remove-users", DepartmentApi.RemoveUsersFromDepartmentEndpoint)
			}

			snippets := adminGroup.Group("/snippets")
			{
				snippets.GET("", SnippetApi.AllEndpoint)
				snippets.GET("/paging", SnippetApi.PagingEndpoint)
				snippets.POST("", SnippetApi.CreateEndpoint)
				snippets.PUT("/:id", SnippetApi.UpdateEndpoint)
				snippets.DELETE("/:id", SnippetApi.DeleteEndpoint)
				snippets.GET("/:id", SnippetApi.GetEndpoint)
			}

			commandFilters := adminGroup.Group("/command-filters")
			{
				commandFilters.GET("", CommandFilterApi.AllEndpoint)
				commandFilters.GET("/paging", CommandFilterApi.PagingEndpoint)
				commandFilters.POST("", CommandFilterApi.CreateEndpoint)
				commandFilters.PUT("/:id", CommandFilterApi.UpdateEndpoint)
				commandFilters.DELETE("/:id", CommandFilterApi.DeleteEndpoint)
				commandFilters.GET("/:id", CommandFilterApi.GetEndpoint)
				commandFilters.POST("/:id/bind", CommandFilterApi.BindEndpoint)
				commandFilters.POST("/:id/unbind", CommandFilterApi.UnbindEndpoint)
			}

			databaseAssets := adminGroup.Group("/database-assets")
			{
				databaseAssets.GET("", DatabaseAssetApi.AllEndpoint)
				databaseAssets.GET("/paging", DatabaseAssetApi.PagingEndpoint)
				databaseAssets.POST("", DatabaseAssetApi.CreateEndpoint)
				databaseAssets.PUT("/:id", DatabaseAssetApi.UpdateEndpoint)
				databaseAssets.DELETE("/:id", DatabaseAssetApi.DeleteEndpoint)
				databaseAssets.GET("/:id", DatabaseAssetApi.GetEndpoint)
				databaseAssets.GET("/:id/decrypted", DatabaseAssetApi.DecryptEndpoint)
			}

			account := adminGroup.Group("/account")
			{
				account.GET("/info", accountApi.InfoEndpoint)
				account.GET("/storage", accountApi.AccountStorageEndpoint)
				account.POST("/logout", accountApi.LogoutEndpoint)
				account.POST("/change-password", accountApi.ChangePasswordEndpoint)
				account.GET("/reload-totp", accountApi.ReloadTOTPEndpoint)
				account.POST("/reset-totp", accountApi.ResetTOTPEndpoint)
				account.POST("/confirm-totp", accountApi.ConfirmTOTPEndpoint)
				account.GET("/access-token", accountApi.AccessTokenGetEndpoint)
				account.POST("/access-token", accountApi.AccessTokenGenEndpoint)
				account.DELETE("/access-token/:id", accountApi.AccessTokenDelEndpoint)
				account.GET("/security-token/support-types", accountApi.SecurityTokenSupportTypesEndpoint)
				account.POST("/security-token/mfa", accountApi.SecurityTokenMfaEndpoint)
				account.POST("/security-token/validate", accountApi.SecurityTokenValidateEndpoint)
			}

			_worker := adminGroup.Group("/worker")
			{
				commands := _worker.Group("/commands")
				{
					workerCommandApi := new(worker.WorkCommandApi)
					commands.GET("", workerCommandApi.CommandAllEndpoint)
					commands.GET("/paging", workerCommandApi.CommandPagingEndpoint)
					commands.POST("", workerCommandApi.CommandCreateEndpoint)
					commands.PUT("/:id", workerCommandApi.CommandUpdateEndpoint)
					commands.DELETE("/:id", workerCommandApi.CommandDeleteEndpoint)
					commands.GET("/:id", workerCommandApi.CommandGetEndpoint)
				}

				assets := _worker.Group("/assets")
				{
					workAssetApi := new(worker.WorkAssetApi)
					assets.GET("/paging", workAssetApi.PagingEndpoint)
					assets.GET("/tags", workAssetApi.TagsEndpoint)
				}
			}

			users := adminGroup.Group("/users", mw.Admin)
			{
				users.GET("", UserApi.AllEndpoint)
				users.GET("/paging", UserApi.PagingEndpoint)
				users.POST("", UserApi.CreateEndpoint)
				users.PUT("/:id", UserApi.UpdateEndpoint)
				users.PATCH("/:id/status", UserApi.UpdateStatusEndpoint)
				users.DELETE("/:id", UserApi.DeleteEndpoint)
				users.GET("/:id", UserApi.GetEndpoint)
				users.POST("/:id/change-password", UserApi.ChangePasswordEndpoint)
				users.POST("/:id/reset-totp", UserApi.ResetTotpEndpoint)
			}

			userGroups := adminGroup.Group("/user-groups", mw.Admin)
			{
				userGroups.POST("", UserGroupApi.UserGroupCreateEndpoint)
				userGroups.GET("", UserGroupApi.UserGroupAllEndpoint)
				userGroups.GET("/paging", UserGroupApi.UserGroupPagingEndpoint)
				userGroups.PUT("/:id", UserGroupApi.UserGroupUpdateEndpoint)
				userGroups.DELETE("/:id", UserGroupApi.UserGroupDeleteEndpoint)
				userGroups.GET("/:id", UserGroupApi.UserGroupGetEndpoint)
			}

			assets := adminGroup.Group("/assets")
			{
				assets.GET("", AssetApi.AssetAllEndpoint)
				assets.POST("", AssetApi.AssetCreateEndpoint)
				assets.POST("/import", AssetApi.AssetImportEndpoint)
				assets.GET("/paging", AssetApi.AssetPagingEndpoint)
				assets.GET("/tags", AssetApi.AssetTagsEndpoint)
				assets.GET("/groups", AssetGroupApi.GroupsGetEndpoint)
				assets.PUT("/groups", AssetGroupApi.GroupsSetEndpoint)
				assets.DELETE("/groups/:id", AssetGroupApi.GroupsDeleteEndpoint)
				assets.GET("/tree", AssetGroupApi.TreeEndpoint)
				assets.POST("/change-group", AssetGroupApi.ChangeGroupEndpoint)
				assets.POST("/change-gateway", AssetGroupApi.ChangeGatewayEndpoint)
				assets.POST("/sort", AssetGroupApi.SortEndpoint)
				assets.GET("/logos", LogoApi.LogosEndpoint)
				assets.POST("/:id/tcping", AssetApi.AssetTcpingEndpoint)
				assets.PUT("/:id", AssetApi.AssetUpdateEndpoint)
				assets.GET("/:id/decrypted", AssetApi.AssetDecryptedEndpoint)
				assets.GET("/:id", AssetApi.AssetGetEndpoint)
				assets.DELETE("/:id", AssetApi.AssetDeleteEndpoint)
				assets.POST("/:id/change-owner", AssetApi.AssetChangeOwnerEndpoint)
			}

			adminGroup.GET("/tags", AssetApi.AssetTagsEndpoint)

			tools := adminGroup.Group("/tools")
			{
				tools.GET("/tcping", ToolsApi.TcpingEndpoint)
				tools.GET("/ping", ToolsApi.PingEndpoint)
			}

			commands := adminGroup.Group("/commands")
			{
				commands.GET("", CommandApi.CommandAllEndpoint)
				commands.GET("/paging", CommandApi.CommandPagingEndpoint)
				commands.POST("", CommandApi.CommandCreateEndpoint)
				commands.PUT("/:id", CommandApi.CommandUpdateEndpoint)
				commands.DELETE("/:id", CommandApi.CommandDeleteEndpoint)
				commands.GET("/:id", CommandApi.CommandGetEndpoint)
				commands.POST("/:id/change-owner", CommandApi.CommandChangeOwnerEndpoint)
			}

			credentials := adminGroup.Group("/credentials")
			{
				credentials.GET("", CredentialApi.CredentialAllEndpoint)
				credentials.GET("/paging", CredentialApi.CredentialPagingEndpoint)
				credentials.POST("", CredentialApi.CredentialCreateEndpoint)
				credentials.POST("/gen-private-key", CredentialApi.GenPrivateKeyEndpoint)
				credentials.PUT("/:id", CredentialApi.CredentialUpdateEndpoint)
				credentials.DELETE("/:id", CredentialApi.CredentialDeleteEndpoint)
				credentials.GET("/:id", CredentialApi.CredentialGetEndpoint)
				credentials.GET("/:id/public-key", CredentialApi.GetPublicKeyEndpoint)
				credentials.GET("/:id/decrypted", CredentialApi.DecryptedEndpoint)
				credentials.POST("/:id/change-owner", CredentialApi.CredentialChangeOwnerEndpoint)
			}

			sessions := adminGroup.Group("/sessions")
			{
				sessions.GET("/paging", SessionApi.SessionPagingEndpoint)
				sessions.POST("/:id/disconnect", SessionApi.SessionDisconnectEndpoint)
				sessions.DELETE("/:id", SessionApi.SessionDeleteEndpoint)
				sessions.GET("/:id/recording", SessionApi.SessionRecordingEndpoint)
				sessions.GET("/:id", SessionApi.SessionGetEndpoint)
				sessions.POST("/:id/reviewed", SessionApi.SessionReviewedEndpoint)
				sessions.POST("/:id/unreviewed", SessionApi.SessionUnViewedEndpoint)
				sessions.POST("/clear", SessionApi.SessionClearEndpoint)
				sessions.POST("/reviewed", SessionApi.SessionReviewedAllEndpoint)

				sessions.POST("", SessionApi.SessionCreateEndpoint)
				sessions.POST("/:id/connect", SessionApi.SessionConnectEndpoint)
				sessions.GET("/:id/tunnel", guacamoleApi.Guacamole)
				sessions.GET("/:id/tunnel-monitor", guacamoleApi.GuacamoleMonitor)
				sessions.GET("/:id/ssh", webTerminalApi.SshEndpoint)
				sessions.GET("/:id/ssh-monitor", webTerminalApi.SshMonitorEndpoint)
				sessions.POST("/:id/resize", SessionApi.SessionResizeEndpoint)
				sessions.GET("/:id/stats", SessionApi.SessionStatsEndpoint)

				sessions.POST("/:id/ls", SessionApi.SessionLsEndpoint)
				sessions.GET("/:id/download", SessionApi.SessionDownloadEndpoint)
				sessions.POST("/:id/upload", SessionApi.SessionUploadEndpoint)
				sessions.POST("/:id/edit", SessionApi.SessionEditEndpoint)
				sessions.POST("/:id/mkdir", SessionApi.SessionMkDirEndpoint)
				sessions.POST("/:id/rm", SessionApi.SessionRmEndpoint)
				sessions.POST("/:id/rename", SessionApi.SessionRenameEndpoint)
				sessions.GET("/audit-enabled", SessionApi.SessionAuditEnabledEndpoint)
				sessions.POST("/:id/audit", SessionApi.SessionTriggerAuditEndpoint)
				sessions.GET("/:id/audit", SessionApi.SessionGetAuditEndpoint)
			}

			loginLogs := adminGroup.Group("/login-logs")
			{
				loginLogs.GET("/paging", LoginLogApi.LoginLogPagingEndpoint)
				loginLogs.DELETE("/:id", LoginLogApi.LoginLogDeleteEndpoint)
				loginLogs.POST("/clear", LoginLogApi.LoginLogClearEndpoint)
			}

			storageLogs := adminGroup.Group("/storage-logs")
			{
				storageLogs.GET("/paging", StorageLogApi.PagingEndpoint)
				storageLogs.DELETE("/:id", StorageLogApi.DeleteEndpoint)
				storageLogs.POST("/clear", StorageLogApi.ClearEndpoint)
			}

			adminGroup.GET("/properties", PropertyApi.PropertyGetEndpoint)
			adminGroup.PUT("/properties", PropertyApi.PropertyUpdateEndpoint)
			adminGroup.POST("/properties/gen-rsa-private-key", PropertyApi.GenRSAPrivateKeyEndpoint)
			adminGroup.POST("/properties/send-mail", PropertyApi.SendMailEndpoint)
			adminGroup.GET("/properties/client-ips", PropertyApi.ClientIPsEndpoint)

			adminGroup.GET("/logos", LogoApi.LogosEndpoint)
			adminGroup.POST("/logos/upload", LogoApi.UploadEndpoint)
			adminGroup.DELETE("/logos/:name", LogoApi.DeleteEndpoint)

			adminGroup.GET("/overview/counter", OverviewApi.OverviewCounterEndPoint)
			adminGroup.GET("/overview/asset", OverviewApi.OverviewAssetEndPoint)
			adminGroup.GET("/overview/date-counter", OverviewApi.OverviewDateCounterEndPoint)
			adminGroup.GET("/overview/ps", OverviewApi.OverviewPS)

			jobs := adminGroup.Group("/jobs")
			{
				jobs.POST("", JobApi.JobCreateEndpoint)
				jobs.GET("/paging", JobApi.JobPagingEndpoint)
				jobs.PUT("/:id", JobApi.JobUpdateEndpoint)
				jobs.POST("/:id/change-status", JobApi.JobChangeStatusEndpoint)
				jobs.POST("/:id/exec", JobApi.JobExecEndpoint)
				jobs.DELETE("/:id", JobApi.JobDeleteEndpoint)
				jobs.GET("/:id", JobApi.JobGetEndpoint)

				jobs.GET("/:id/logs/paging", JobApi.JobGetLogsEndpoint)
				jobs.DELETE("/:id/logs", JobApi.JobDeleteLogsEndpoint)
			}

			securities := adminGroup.Group("/securities")
			{
				securities.POST("", SecurityApi.SecurityCreateEndpoint)
				securities.GET("/paging", SecurityApi.SecurityPagingEndpoint)
				securities.PUT("/:id", SecurityApi.SecurityUpdateEndpoint)
				securities.DELETE("/:id", SecurityApi.SecurityDeleteEndpoint)
				securities.GET("/:id", SecurityApi.SecurityGetEndpoint)
			}

			storages := adminGroup.Group("/storages")
			{
				storages.GET("/paging", StorageApi.StoragePagingEndpoint)
				storages.POST("", StorageApi.StorageCreateEndpoint)
				storages.DELETE("/:id", StorageApi.StorageDeleteEndpoint)
				storages.PUT("/:id", StorageApi.StorageUpdateEndpoint)
				storages.GET("/shares", StorageApi.StorageSharesEndpoint)
				storages.GET("/:id", StorageApi.StorageGetEndpoint)

				storages.POST("/:storageId/ls", StorageApi.StorageLsEndpoint)
				storages.GET("/:storageId/download", StorageApi.StorageDownloadEndpoint)
				storages.POST("/:storageId/upload", StorageApi.StorageUploadEndpoint)
				storages.POST("/:storageId/mkdir", StorageApi.StorageMkDirEndpoint)
				storages.POST("/:storageId/rm", StorageApi.StorageRmEndpoint)
				storages.POST("/:storageId/rename", StorageApi.StorageRenameEndpoint)
				storages.POST("/:storageId/edit", StorageApi.StorageEditEndpoint)
			}

			strategies := adminGroup.Group("/strategies")
			{
				strategies.GET("", StrategyApi.StrategyAllEndpoint)
				strategies.GET("/paging", StrategyApi.StrategyPagingEndpoint)
				strategies.POST("", StrategyApi.StrategyCreateEndpoint)
				strategies.DELETE("/:id", StrategyApi.StrategyDeleteEndpoint)
				strategies.PUT("/:id", StrategyApi.StrategyUpdateEndpoint)
				strategies.GET("/:id", StrategyApi.GetEndpoint)
			}

			accessGateways := adminGroup.Group("/access-gateways")
			{
				accessGateways.GET("", AccessGatewayApi.AccessGatewayAllEndpoint)
				accessGateways.POST("", AccessGatewayApi.AccessGatewayCreateEndpoint)
				accessGateways.GET("/paging", AccessGatewayApi.AccessGatewayPagingEndpoint)
				accessGateways.PUT("/:id", AccessGatewayApi.AccessGatewayUpdateEndpoint)
				accessGateways.DELETE("/:id", AccessGatewayApi.AccessGatewayDeleteEndpoint)
				accessGateways.GET("/:id", AccessGatewayApi.AccessGatewayGetEndpoint)
			}

			agentGateways := adminGroup.Group("/agent-gateways")
			{
				agentGateways.GET("", AgentGatewayApi.AllEndpoint)
				agentGateways.POST("", AgentGatewayApi.CreateEndpoint)
				agentGateways.GET("/paging", AgentGatewayApi.PagingEndpoint)
				agentGateways.PUT("/:id", AgentGatewayApi.UpdateEndpoint)
				agentGateways.DELETE("/:id", AgentGatewayApi.DeleteEndpoint)
				agentGateways.GET("/:id", AgentGatewayApi.GetEndpoint)
				agentGateways.GET("/get-register-param", AgentGatewayApi.GetRegisterParamEndpoint)
				agentGateways.POST("/set-register-addr", AgentGatewayApi.SetRegisterAddrEndpoint)
				agentGateways.GET("/:id/stat", AgentGatewayApi.GetStatEndpoint)
				agentGateways.POST("/sort", AgentGatewayApi.UpdateSortEndpoint)
			}

			adminGroup.GET("/agent/version", AgentGatewayApi.VersionEndpoint)

			sshGateways := adminGroup.Group("/ssh-gateways")
			{
				sshGateways.GET("", SshGatewayApi.AllEndpoint)
				sshGateways.POST("", SshGatewayApi.CreateEndpoint)
				sshGateways.GET("/paging", SshGatewayApi.PagingEndpoint)
				sshGateways.PUT("/:id", SshGatewayApi.UpdateEndpoint)
				sshGateways.DELETE("/:id", SshGatewayApi.DeleteEndpoint)
				sshGateways.GET("/:id", SshGatewayApi.GetEndpoint)
				sshGateways.GET("/:id/decrypted", SshGatewayApi.DecryptedEndpoint)
			}

			adminGroup.GET("/assets/ssh/available-for-gateway", SshGatewayApi.AvailableForGatewayEndpoint)

			gatewayGroups := adminGroup.Group("/gateway-groups")
			{
				gatewayGroups.GET("", GatewayGroupApi.AllEndpoint)
				gatewayGroups.POST("", GatewayGroupApi.CreateEndpoint)
				gatewayGroups.GET("/paging", GatewayGroupApi.PagingEndpoint)
				gatewayGroups.PUT("/:id", GatewayGroupApi.UpdateEndpoint)
				gatewayGroups.DELETE("/:id", GatewayGroupApi.DeleteEndpoint)
				gatewayGroups.GET("/:id", GatewayGroupApi.GetEndpoint)
			}

			websites := adminGroup.Group("/websites")
			{
				websites.GET("", WebsiteApi.AllEndpoint)
				websites.POST("", WebsiteApi.CreateEndpoint)
				websites.GET("/paging", WebsiteApi.PagingEndpoint)
				websites.PUT("/:id", WebsiteApi.UpdateEndpoint)
				websites.DELETE("/:id", WebsiteApi.DeleteEndpoint)
				websites.GET("/:id", WebsiteApi.GetEndpoint)
				websites.GET("/groups", WebsiteApi.GroupsGetEndpoint)
				websites.PUT("/groups", WebsiteApi.GroupsSetEndpoint)
				websites.DELETE("/groups/:id", WebsiteApi.GroupsDeleteEndpoint)
				websites.POST("/change-group", WebsiteApi.ChangeGroupEndpoint)
				websites.POST("/change-gateway", WebsiteApi.ChangeGatewayEndpoint)
				websites.POST("/sort", WebsiteApi.SortEndpoint)
				websites.GET("/favicon", WebsiteApi.FaviconEndpoint)
			}

			certificates := adminGroup.Group("/certificates")
			{
				certificates.GET("", CertificateApi.AllEndpoint)
				certificates.POST("", CertificateApi.CreateEndpoint)
				certificates.GET("/paging", CertificateApi.PagingEndpoint)
				certificates.PUT("/:id", CertificateApi.UpdateEndpoint)
				certificates.DELETE("/:id", CertificateApi.DeleteEndpoint)
				certificates.GET("/:id", CertificateApi.GetEndpoint)
				certificates.PATCH("/:id/default", CertificateApi.UpdateDefaultEndpoint)
				certificates.GET("/:id/download", CertificateApi.DownloadEndpoint)
				certificates.POST("/:id/renew", CertificateApi.RenewEndpoint)
			}

			backup := adminGroup.Group("/backup")
			{
				backup.GET("/export", BackupApi.BackupExportEndpoint)
				backup.POST("/import", BackupApi.BackupImportEndpoint)
			}

			tenants := adminGroup.Group("/tenants")
			{
				tenants.GET("", TenantApi.AllEndpoint)
				tenants.GET("/paging", TenantApi.PagingEndpoint)
				tenants.POST("", TenantApi.CreateEndpoint)
				tenants.DELETE("/:id", TenantApi.DeleteEndpoint)
				tenants.PUT("/:id", TenantApi.UpdateEndpoint)
			}

			roles := adminGroup.Group("/roles")
			{
				roles.GET("", RoleApi.AllEndpoint)
				roles.GET("/paging", RoleApi.PagingEndpoint)
				roles.GET("/:id", RoleApi.GetEndpoint)
				roles.POST("", RoleApi.CreateEndpoint)
				roles.DELETE("/:id", RoleApi.DeleteEndpoint)
				roles.PUT("/:id", RoleApi.UpdateEndpoint)
			}

			loginPolicies := adminGroup.Group("/login-policies")
			{
				loginPolicies.GET("/paging", LoginPolicyApi.PagingEndpoint)
				loginPolicies.GET("/:id", LoginPolicyApi.GetEndpoint)
				loginPolicies.GET("/:id/users/paging", LoginPolicyApi.GetUserPageEndpoint)
				loginPolicies.GET("/:id/users/id", LoginPolicyApi.GetUserIdEndpoint)
				loginPolicies.POST("", LoginPolicyApi.CreateEndpoint)
				loginPolicies.DELETE("/:id", LoginPolicyApi.DeleteEndpoint)
				loginPolicies.PUT("/:id", LoginPolicyApi.UpdateEndpoint)
				loginPolicies.POST("/:id/bind", LoginPolicyApi.BindEndpoint)
				loginPolicies.POST("/:id/unbind", LoginPolicyApi.UnbindEndpoint)
			}

			authorised := adminGroup.Group("/authorised")
			{
				authorised.GET("/assets/paging", AuthorisedApi.PagingAsset)
				authorised.GET("/users/paging", AuthorisedApi.PagingUser)
				authorised.GET("/user-groups/paging", AuthorisedApi.PagingUserGroup)
				authorised.GET("/selected", AuthorisedApi.Selected)
				authorised.POST("/assets", AuthorisedApi.AuthorisedAssets)
				authorised.POST("/users", AuthorisedApi.AuthorisedUsers)
				authorised.POST("/user-groups", AuthorisedApi.AuthorisedUserGroups)
				authorised.DELETE("/:id", AuthorisedApi.Delete)
			}

			adminGroup.GET("/menus", RoleApi.TreeMenus)

			ScheduledTaskApi := new(api.ScheduledTaskApi)
			scheduledTasks := adminGroup.Group("/scheduled-tasks")
			{
				scheduledTasks.GET("", ScheduledTaskApi.AllEndpoint)
				scheduledTasks.GET("/paging", ScheduledTaskApi.PagingEndpoint)
				scheduledTasks.POST("", ScheduledTaskApi.CreateEndpoint)
				scheduledTasks.PUT("/:id", ScheduledTaskApi.UpdateEndpoint)
				scheduledTasks.DELETE("/:id", ScheduledTaskApi.DeleteEndpoint)
				scheduledTasks.GET("/:id", ScheduledTaskApi.GetEndpoint)
				scheduledTasks.POST("/:id/change-status", ScheduledTaskApi.ChangeStatusEndpoint)
				scheduledTasks.POST("/:id/exec", ScheduledTaskApi.ExecEndpoint)
				scheduledTasks.GET("/:id/logs/paging", ScheduledTaskApi.GetLogsEndpoint)
				scheduledTasks.DELETE("/:id/logs", ScheduledTaskApi.DeleteLogsEndpoint)
				scheduledTasks.POST("/next-ten-runs", ScheduledTaskApi.NextTenRunsEndpoint)
			}

			SessionCommandApi := new(api.SessionCommandApi)
			sessionCommands := adminGroup.Group("/session-commands")
			{
				sessionCommands.GET("", SessionCommandApi.AllEndpoint)
				sessionCommands.GET("/paging", SessionCommandApi.PagingEndpoint)
				sessionCommands.GET("/:id", SessionCommandApi.GetEndpoint)
			}

			OperationLogApi := new(api.OperationLogApi)
			operationLogs := adminGroup.Group("/operation-logs")
			{
				operationLogs.GET("", OperationLogApi.AllEndpoint)
				operationLogs.GET("/paging", OperationLogApi.PagingEndpoint)
				operationLogs.DELETE("/:id", OperationLogApi.DeleteEndpoint)
				operationLogs.POST("/clear", OperationLogApi.ClearEndpoint)
			}

			OidcClientApi := new(api.OidcClientApi)
			oidcClients := adminGroup.Group("/oidc-clients")
			{
				oidcClients.GET("", OidcClientApi.AllEndpoint)
				oidcClients.GET("/paging", OidcClientApi.PagingEndpoint)
				oidcClients.POST("", OidcClientApi.CreateEndpoint)
				oidcClients.PUT("/:id", OidcClientApi.UpdateEndpoint)
				oidcClients.DELETE("/:id", OidcClientApi.DeleteEndpoint)
				oidcClients.GET("/:id", OidcClientApi.GetEndpoint)
				oidcClients.POST("/:id/regenerate-secret", OidcClientApi.RegenerateSecretEndpoint)
				oidcClients.PATCH("/:id/status", OidcClientApi.UpdateStatusEndpoint)
			}

			LoginLockedApi := new(api.LoginLockedApi)
			loginLocked := adminGroup.Group("/login-locked")
			{
				loginLocked.GET("", LoginLockedApi.AllEndpoint)
				loginLocked.GET("/paging", LoginLockedApi.PagingEndpoint)
				loginLocked.DELETE("/:id", LoginLockedApi.DeleteEndpoint)
			}

			FilesystemLogApi := new(api.FilesystemLogApi)
			filesystemLogs := adminGroup.Group("/filesystem-logs")
			{
				filesystemLogs.GET("", FilesystemLogApi.AllEndpoint)
				filesystemLogs.GET("/paging", FilesystemLogApi.PagingEndpoint)
				filesystemLogs.DELETE("/:id", FilesystemLogApi.DeleteEndpoint)
				filesystemLogs.POST("/clear", FilesystemLogApi.ClearEndpoint)
			}

			CommandFilterRuleApi := new(api.CommandFilterRuleApi)
			commandFilterRules := adminGroup.Group("/command-filter-rules")
			{
				commandFilterRules.GET("", CommandFilterRuleApi.AllEndpoint)
				commandFilterRules.GET("/paging", CommandFilterRuleApi.PagingEndpoint)
				commandFilterRules.POST("", CommandFilterRuleApi.CreateEndpoint)
				commandFilterRules.PUT("/:id", CommandFilterRuleApi.UpdateEndpoint)
				commandFilterRules.DELETE("/:id", CommandFilterRuleApi.DeleteEndpoint)
				commandFilterRules.GET("/:id", CommandFilterRuleApi.GetEndpoint)
			}

			AgentGatewayTokenApi := new(api.AgentGatewayTokenApi)
			agentGatewayTokens := adminGroup.Group("/agent-gateway-tokens")
			{
				agentGatewayTokens.GET("", AgentGatewayTokenApi.AllEndpoint)
				agentGatewayTokens.GET("/paging", AgentGatewayTokenApi.PagingEndpoint)
				agentGatewayTokens.POST("", AgentGatewayTokenApi.CreateEndpoint)
				agentGatewayTokens.PUT("/:id", AgentGatewayTokenApi.UpdateEndpoint)
				agentGatewayTokens.DELETE("/:id", AgentGatewayTokenApi.DeleteEndpoint)
				agentGatewayTokens.GET("/:id", AgentGatewayTokenApi.GetEndpoint)
			}

			AccessLogApi := new(api.AccessLogApi)
			accessLogs := adminGroup.Group("/access-logs")
			{
				accessLogs.GET("", AccessLogApi.AllEndpoint)
				accessLogs.GET("/paging", AccessLogApi.PagingEndpoint)
				accessLogs.DELETE("/:id", AccessLogApi.DeleteEndpoint)
				accessLogs.POST("/clear", AccessLogApi.ClearEndpoint)
				accessLogs.GET("/domain-stats", AccessLogApi.GetDomainStatsEndpoint)
				accessLogs.GET("/daily-stats", AccessLogApi.GetDailyStatsEndpoint)
				accessLogs.GET("/status-code-stats", AccessLogApi.GetStatusCodeStatsEndpoint)
				accessLogs.GET("/hourly-stats", AccessLogApi.GetHourlyStatsEndpoint)
				accessLogs.GET("/total-stats", AccessLogApi.GetTotalStatsEndpoint)
				accessLogs.GET("/website-stats", AccessLogApi.GetWebsiteStatsEndpoint)
				accessLogs.GET("/website-traffic-trend", AccessLogApi.GetWebsiteTrafficTrendEndpoint)
				accessLogs.GET("/top-pages", AccessLogApi.GetTopPagesEndpoint)
				accessLogs.GET("/top-referers", AccessLogApi.GetTopReferersEndpoint)
				accessLogs.GET("/realtime-metrics", AccessLogApi.GetRealtimeMetricsEndpoint)
				accessLogs.GET("/website-hourly-stats", AccessLogApi.GetWebsiteHourlyStatsEndpoint)
				accessLogs.GET("/website-status-code-stats", AccessLogApi.GetWebsiteStatusCodeStatsEndpoint)
			}

			AuthorisedAssetApi := new(api.AuthorisedAssetApi)
			authorisedAsset := adminGroup.Group("/authorised-asset")
			{
				authorisedAsset.GET("/paging", AuthorisedAssetApi.PagingEndpoint)
				authorisedAsset.POST("/assets", AuthorisedAssetApi.AuthorisedAssetsEndpoint)
				authorisedAsset.POST("/users", AuthorisedAssetApi.AuthorisedUsersEndpoint)
				authorisedAsset.POST("/departments", AuthorisedAssetApi.AuthorisedDepartmentsEndpoint)
				authorisedAsset.GET("/selected", AuthorisedAssetApi.SelectedEndpoint)
				authorisedAsset.DELETE("/:id", AuthorisedAssetApi.DeleteEndpoint)
				authorisedAsset.GET("/:id", AuthorisedAssetApi.GetEndpoint)
				authorisedAsset.PUT("/:id", AuthorisedAssetApi.UpdateEndpoint)
				authorisedAsset.POST("", AuthorisedAssetApi.CreateEndpoint)
			}

			AuthorisedDatabaseAssetApi := new(api.AuthorisedDatabaseAssetApi)
			authorisedDatabaseAssets := adminGroup.Group("/authorised-database-assets")
			{
				authorisedDatabaseAssets.GET("/paging", AuthorisedDatabaseAssetApi.PagingEndpoint)
				authorisedDatabaseAssets.GET("/selected", AuthorisedDatabaseAssetApi.SelectedEndpoint)
				authorisedDatabaseAssets.DELETE("/:id", AuthorisedDatabaseAssetApi.DeleteEndpoint)
				authorisedDatabaseAssets.GET("/:id", AuthorisedDatabaseAssetApi.GetEndpoint)
				authorisedDatabaseAssets.PUT("/:id", AuthorisedDatabaseAssetApi.UpdateEndpoint)
				authorisedDatabaseAssets.POST("", AuthorisedDatabaseAssetApi.CreateEndpoint)
			}

			AuthorisedWebsiteApi := new(api.AuthorisedWebsiteApi)
			authorisedWebsite := adminGroup.Group("/authorised-website")
			{
				authorisedWebsite.GET("/paging", AuthorisedWebsiteApi.PagingEndpoint)
				authorisedWebsite.DELETE("/:id", AuthorisedWebsiteApi.DeleteEndpoint)
				authorisedWebsite.POST("", AuthorisedWebsiteApi.CreateEndpoint)
			}

			DbWorkOrderApi := new(api.DbWorkOrderApi)
			dbWorkOrders := adminGroup.Group("/db-work-orders")
			{
				dbWorkOrders.GET("/paging", DbWorkOrderApi.PagingEndpoint)
				dbWorkOrders.GET("/:id", DbWorkOrderApi.GetEndpoint)
				dbWorkOrders.POST("", DbWorkOrderApi.CreateEndpoint)
				dbWorkOrders.POST("/:id/approve", DbWorkOrderApi.ApproveEndpoint)
				dbWorkOrders.POST("/:id/reject", DbWorkOrderApi.RejectEndpoint)
				dbWorkOrders.DELETE("/:id", DbWorkOrderApi.DeleteEndpoint)
			}

			DatabaseSQLLogApi := new(api.DatabaseSQLLogApi)
			databaseSqlLogs := adminGroup.Group("/database-sql-logs")
			{
				databaseSqlLogs.GET("/paging", DatabaseSQLLogApi.PagingEndpoint)
				databaseSqlLogs.POST("/clear", DatabaseSQLLogApi.ClearEndpoint)
			}

			DnsProviderApi := new(api.DnsProviderApi)
			dnsProviders := adminGroup.Group("/dns-providers")
			{
				dnsProviders.GET("/config", DnsProviderApi.GetConfigEndpoint)
				dnsProviders.PUT("/config", DnsProviderApi.SetConfigEndpoint)
				dnsProviders.DELETE("/config", DnsProviderApi.DeleteConfigEndpoint)
			}

			LicenseApi := new(api.LicenseApi)
			adminGroup.GET("/license/machine-id", LicenseApi.GetMachineIdEndpoint)
			adminGroup.GET("/license", LicenseApi.GetLicenseEndpoint)
			adminGroup.POST("/license", LicenseApi.SetLicenseEndpoint)
			adminGroup.POST("/license/request", LicenseApi.RequestLicenseEndpoint)
			apiGroup.GET("/license", LicenseApi.GetSimpleLicenseEndpoint)

			WebsiteTempAllowApi := new(api.WebsiteTempAllowApi)
			adminGroup.GET("/website-temp-allow", WebsiteTempAllowApi.ListEndpoint)
			adminGroup.DELETE("/website-temp-allow", WebsiteTempAllowApi.DeleteEndpoint)
		}

		portalGroup := apiGroup.Group("/portal")
		{
			portalGroup.GET("/assets", PortalApi.AssetsEndpoint)
			portalGroup.GET("/database-assets", PortalApi.DatabaseAssetsEndpoint)
			portalGroup.GET("/assets/tree", PortalApi.AssetsTreeEndpoint)
			portalGroup.GET("/websites/tree", PortalApi.WebsitesTreeEndpoint)
			portalGroup.GET("/assets/group-tree", PortalApi.AssetsGroupTreeEndpoint)
			portalGroup.GET("/websites/group-tree", PortalApi.WebsitesGroupTreeEndpoint)
			portalGroup.GET("/access-require-mfa", PortalApi.AccessRequireMfaEndpoint)
			portalGroup.POST("/sessions", PortalApi.CreateSessionEndpoint)
			portalGroup.GET("/sessions/:id", PortalApi.GetSessionEndpoint)
			portalGroup.GET("/sessions/:id/share", PortalApi.GetShareEndpoint)
			portalGroup.POST("/sessions/:id/share", PortalApi.CreateShareEndpoint)
			portalGroup.DELETE("/sessions/:id/share", PortalApi.CancelShareEndpoint)
			portalGroup.GET("/website/access", PortalApi.AccessWebsiteEndpoint)
			portalGroup.POST("/website/allow-ip", PortalApi.AllowWebsiteIpEndpoint)
			portalGroup.POST("/assets/:id/wol", PortalApi.WakeOnLanEndpoint)
			portalGroup.POST("/assets/:id/ping", PortalApi.PingAssetEndpoint)

			SnippetUserApi := new(api.SnippetUserApi)
			portalGroup.GET("/snippets", SnippetUserApi.AllEndpoint)
			portalGroup.GET("/snippets/paging", SnippetUserApi.PagingEndpoint)
			portalGroup.GET("/snippets/:id", SnippetUserApi.GetEndpoint)
		}

		DbWorkOrderUserApi := new(api.DbWorkOrderApi)
		apiGroup.GET("/db-work-orders/paging", DbWorkOrderUserApi.PagingEndpoint)
		apiGroup.GET("/db-work-orders/:id", DbWorkOrderUserApi.GetEndpoint)
		apiGroup.POST("/db-work-orders", DbWorkOrderUserApi.CreateEndpoint)

		OidcApi := new(api.OidcApi)
		apiGroup.GET("/oidc/authorize", OidcApi.AuthorizeEndpoint)
		apiGroup.POST("/oidc/login", OidcApi.LoginEndpoint)

		WechatWorkApi := new(api.WechatWorkApi)
		apiGroup.GET("/wechat-work/authorize", WechatWorkApi.AuthorizeEndpoint)
		apiGroup.POST("/wechat-work/login", WechatWorkApi.LoginEndpoint)

		apiGroup.GET("/access/terminal/:id/stats", PortalApi.TerminalStatsEndpoint)

		apiGroup.GET("/access/settings", AccessSettingApi.GetEndpoint)
		apiGroup.PUT("/access/settings", AccessSettingApi.SetEndpoint)
		apiGroup.GET("/access/settings/shell-assistant-enabled", AccessSettingApi.ShellAssistantEnabledEndpoint)
		apiGroup.POST("/access/settings/shell-assistant", AccessSettingApi.ShellAssistantEndpoint)
		apiGroup.GET("/access/terminal", webTerminalApi.AccessTerminalEndpoint)

		filesystem := apiGroup.Group("/access/filesystem")
		{
			filesystem.GET("/:id/ls", FileSystemApi.LsEndpoint)
			filesystem.POST("/:id/mkdir", FileSystemApi.MkdirEndpoint)
			filesystem.POST("/:id/touch", FileSystemApi.TouchEndpoint)
			filesystem.POST("/:id/rm", FileSystemApi.RmEndpoint)
			filesystem.POST("/:id/rename", FileSystemApi.RenameEndpoint)
			filesystem.POST("/:id/edit", FileSystemApi.EditEndpoint)
			filesystem.GET("/:id/read", FileSystemApi.ReadEndpoint)
			filesystem.POST("/:id/chmod", FileSystemApi.ChmodEndpoint)
			filesystem.GET("/:id/upload/progress", FileSystemApi.UploadProgressEndpoint)
			filesystem.GET("/:id/download", FileSystemApi.DownloadEndpoint)
			filesystem.POST("/:id/upload", FileSystemApi.UploadEndpoint)
		}
	}

	return e
}