handlers

var CreateApp = operations.CreateAppHandlerFunc(
	func(params operations.CreateAppParams) middleware.Responder {
		log.V("handlers.CreateApp()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		if params.App == nil {
			return operations.NewCreateAppBadRequest().WithPayload("Request body is required")
		}
		inputApp := *params.App
		err = validation.AppName(inputApp.Name)
		if err != nil {
			return operations.NewCreateAppBadRequest().WithPayload(err.Error())
		}
		existingApp, _ := app_service.Get(tx, inputApp.Name)
		if existingApp != nil {
			log.D("Existing app: %v", existingApp)
			return operations.NewCreateAppBadRequest().WithPayload(fmt.Sprintf("%s already exists", inputApp.Name))
		}

		err = docker_service.PullImage(inputApp.Image)
		if err != nil {
			return operations.NewCreateAppBadRequest().WithPayload(err.Error())
		}
		digest, err := docker_service.GetImageDigest(inputApp.Image)
		if err != nil {
			return operations.NewCreateAppDefault(500).WithPayload(err.Error())
		}

		newApp, err := app_service.Create(tx, inputApp)
		if err != nil {
			return operations.NewCreateAppDefault(500).WithPayload(err.Error())
		}

		defaultRunConfig := &models.RunConfig{
			AppID:       newApp.ID,
			ImageDigest: digest,
		}
		err = run_config_service.Create(tx, defaultRunConfig)
		if err != nil {
			return operations.NewCreateAppDefault(500).WithPayload(err.Error())
		}

		return operations.NewCreateAppCreated().WithPayload(newApp)
	},
)

var DeleteApp = operations.DeleteAppHandlerFunc(
	func(params operations.DeleteAppParams) middleware.Responder {
		log.V("handlers.DeleteApp()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		app, _ := app_service.Get(tx, params.AppName)
		if app == nil {
			return operations.NewDeleteAppNotFound().
				WithPayload(fmt.Sprintf("%s does not exist", params.AppName))
		}

		err = app_service.Delete(tx, app)
		if err != nil {
			return operations.NewDeleteAppDefault(500).WithPayload(err.Error())
		}

		return operations.NewDeleteAppOK().WithPayload(app)
	},
)

var EditApp = operations.EditAppHandlerFunc(
	func(params operations.EditAppParams) middleware.Responder {
		log.V("handlers.EditApp()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		app, err := app_service.Get(tx, params.AppName)
		if err != nil {
			return operations.NewEditAppNotFound().WithPayload(err.Error())
		}

		err = validation.AppEdit(params.NewApp)
		if err != nil {
			return operations.NewEditAppBadRequest().WithPayload(err.Error())
		}

		newApp := &models.App{
			ID:     app.ID,
			Image:  app.Image,
			Name:   params.NewApp.Name,
			Group:  params.NewApp.Group,
			Hidden: params.NewApp.Hidden,
		}
		err = app_service.Upsert(tx, newApp)
		if err != nil {
			return operations.NewEditAppDefault(500).WithPayload(err.Error())
		}

		return operations.NewEditAppOK().WithPayload(newApp)
	},
)

var GetApp = operations.GetAppHandlerFunc(
	func(params operations.GetAppParams) middleware.Responder {
		log.V("handlers.GetApp()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		app, err := app_service.Get(db, params.AppName)
		if err != nil {
			return operations.NewGetAppNotFound().WithPayload(err.Error())
		}
		return operations.NewGetAppOK().WithPayload(app)
	},
)

var GetAppEnv = operations.GetAppEnvHandlerFunc(
	func(params operations.GetAppEnvParams) middleware.Responder {
		log.V("handlers.GetAppEnv()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		appID, err := app_service.GetAppID(db, params.AppName)
		if err != nil {
			return operations.NewGetAppEnvNotFound().WithPayload(err.Error())
		}

		appEnv, err := env_service.Get(db, appID)
		if err != nil {
			return operations.NewGetAppEnvDefault(500).WithPayload(err.Error())
		}

		return operations.NewGetAppEnvOK().WithPayload(appEnv)
	},
)

var GetAppTraefikConfig = operations.GetAppTraefikConfigHandlerFunc(
	func(params operations.GetAppTraefikConfigParams) middleware.Responder {
		log.V("handlers.GetAppTraefikConfig()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		if !plugin_service.IsInstalled(db, constants.PluginNameTraefik) {
			return operations.NewGetAppTraefikConfigBadRequest().
				WithPayload("Traefik is not installed")
		}

		appID := params.AppID.String()
		plugins, err := plugin_service.GetAppPlugins(db, appID)
		if err != nil {
			return operations.NewGetAppTraefikConfigDefault(500).WithPayload(err.Error())
		}
		traefikConfig := plugins.Traefik
		if traefikConfig == nil {
			return operations.NewGetAppTraefikConfigNotFound()
		}

		return operations.NewGetAppTraefikConfigOK().WithPayload(traefikConfig)
	},
)

var GetPlugin = operations.GetPluginHandlerFunc(
	func(params operations.GetPluginParams) middleware.Responder {
		log.V("handlers.GetPlugin()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		plugin, err := plugin_service.Get(db, params.PluginName)
		if err != nil {
			return operations.NewGetPluginNotFound().WithPayload(err.Error())
		}
		return operations.NewGetPluginOK().WithPayload(plugin)
	},
)

var GetRunConfig = operations.GetRunConfigHandlerFunc(
	func(params operations.GetRunConfigParams) middleware.Responder {
		log.V("handlers.GetRunConfig()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		appID, err := app_service.GetAppID(db, params.AppName)
		if err != nil {
			return operations.NewGetRunConfigNotFound().WithPayload(err.Error())
		}

		appConfig, err := run_config_service.Get(db, appID)
		if err != nil {
			return operations.NewGetRunConfigNotFound().WithPayload(err.Error())
		}

		return operations.NewGetRunConfigOK().WithPayload(appConfig)
	},
)

var HealthCheck = operations.HealthCheckHandlerFunc(
	func(params operations.HealthCheckParams) middleware.Responder {
		log.V("handlers.HealthCheck()")
		dockerVersion := docker_service.Version()
		swarm := docker_service.SwarmInfo()

		return operations.NewHealthCheckOK().WithPayload(&models.Health{
			Version:       shared.StringPtr(fmt.Sprintf("v%v-%v-%v", constants.VERSION, constants.BUILD_DATE, constants.BUILD_HASH)),
			DockerVersion: dockerVersion,
			Swarm: &models.HealthSwarm{
				ID:          swarm.ID,
				CreatedAt:   swarm.CreatedAt.String(),
				UpdatedAt:   swarm.UpdatedAt.String(),
				JoinCommand: fmt.Sprintf("docker swarm join --token %s <miasma-ip:port>", swarm.JoinTokens.Worker),
			},
		})
	},
)

var InstallPlugin = operations.InstallPluginHandlerFunc(
	func(params operations.InstallPluginParams) middleware.Responder {
		log.V("handlers.InstallPlugin()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		plugin, pluginDetails, err := plugin_service.Install(tx, params.PluginName)
		if err != nil {
			return operations.NewInstallPluginDefault(500).WithPayload(err.Error())
		}

		plugins, err := plugin_service.GetAppPlugins(tx, pluginDetails.App.ID.String())
		if err != nil {
			return operations.NewStartAppDefault(500).WithPayload(err.Error())
		}

		err = app_service.Start(tx, pluginDetails, plugins)
		if err != nil {
			return operations.NewStartAppDefault(500).WithPayload(err.Error())
		}

		return operations.NewInstallPluginCreated().WithPayload(plugin)
	},
)

var ListApps = operations.ListAppsHandlerFunc(
	func(params operations.ListAppsParams) middleware.Responder {
		log.V("handlers.ListApps()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		showHidden := params.Hidden != nil && *params.Hidden
		apps, err := app_service.List(db, showHidden)
		if err != nil {
			return operations.NewListAppsDefault(500).WithPayload(err.Error())
		}

		return operations.NewListAppsOK().WithPayload(apps)
	},
)

var ListPlugins = operations.ListPluginsHandlerFunc(
	func(params operations.ListPluginsParams) middleware.Responder {
		log.V("handlers.ListPlugins()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		plugins := plugin_service.List(db)
		return operations.NewListPluginsOK().WithPayload(plugins)
	},
)

var RemoveAppTraefikConfig = operations.RemoveAppTraefikConfigHandlerFunc(
	func(params operations.RemoveAppTraefikConfigParams) middleware.Responder {
		log.V("handlers.RemoveAppTraefikConfig()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		if !plugin_service.IsInstalled(tx, constants.PluginNameTraefik) {
			return operations.NewRemoveAppTraefikConfigBadRequest().WithPayload("Traefik is not installed")
		}
		appID := params.AppID.String()

		plugins, err := plugin_service.GetAppPlugins(tx, appID)
		if plugins.Traefik == nil {
			return operations.NewRemoveAppTraefikConfigBadRequest().
				WithPayload(fmt.Sprintf("No traefik config to delete for '%v'", appID))
		}
		if err != nil {
			return operations.NewRemoveAppTraefikConfigDefault(500).WithPayload(err.Error())
		}

		err = plugin_service.DeleteTraefikConfig(tx, appID)
		if err != nil {
			return operations.NewRemoveAppTraefikConfigDefault(500).WithPayload(err.Error())
		}

		return operations.NewRemoveAppTraefikConfigOK().WithPayload(plugins.Traefik)
	},
)

var StartApp = operations.StartAppHandlerFunc(
	func(params operations.StartAppParams) middleware.Responder {
		log.V("handlers.StartApp()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		details, err := app_service.Details(db, params.AppName)
		if err != nil {
			return operations.NewStartAppNotFound().WithPayload(fmt.Sprintf("%s does not exist", params.AppName))
		}
		appId := details.App.ID.String()

		plugins, err := plugin_service.GetAppPlugins(db, appId)
		if err != nil {
			return operations.NewStartAppDefault(500).WithPayload(err.Error())
		}

		err = app_service.Start(db, details, plugins)
		if err != nil {
			return operations.NewStartAppDefault(500).WithPayload(err.Error())
		}
		return operations.NewStartAppNoContent()
	},
)

var StopApp = operations.StopAppHandlerFunc(
	func(params operations.StopAppParams) middleware.Responder {
		log.V("handlers.StopApp()")
		db, onDefer := database.ReadOnly()
		defer onDefer()

		app, _ := app_service.Get(db, params.AppName)
		if app == nil {
			return operations.NewStopAppNotFound().WithPayload(fmt.Sprintf("%s does not exist", params.AppName))
		}

		err := app_service.Stop(app)
		if err != nil {
			return operations.NewStopAppDefault(500).WithPayload(err.Error())
		}
		return operations.NewStopAppNoContent()
	},
)

var UninstallPlugin = operations.UninstallPluginHandlerFunc(
	func(params operations.UninstallPluginParams) middleware.Responder {
		log.V("handlers.UninstallPlugin()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		plugin, pluginApp, err := plugin_service.Uninstall(tx, params.PluginName)
		if err != nil {
			return operations.NewUninstallPluginDefault(500).WithPayload(err.Error())
		}

		err = app_service.Stop(pluginApp)
		if err != nil {
			return operations.NewUninstallPluginDefault(500).WithPayload(err.Error())
		}

		return operations.NewUninstallPluginOK().WithPayload(plugin)
	},
)

var UpdateAppEnv = operations.UpdateAppEnvHandlerFunc(
	func(params operations.UpdateAppEnvParams) middleware.Responder {
		log.V("handlers.UpdateAppEnv()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		newEnv := params.NewEnv.(map[string]interface{})
		if err := validation.AppEnv(newEnv); err != nil {
			return operations.NewUpdateAppEnvBadRequest().
				WithPayload(err.Error())
		}

		details, err := app_service.Details(tx, params.AppName)
		if err != nil {
			return operations.NewUpdateAppEnvNotFound().WithPayload(err.Error())
		}
		appID := details.App.ID.String()

		err = env_service.Update(tx, appID, newEnv)
		if err != nil {
			return operations.NewUpdateAppEnvDefault(500).WithPayload(err.Error())
		}

		env, err := env_service.Get(tx, appID)
		if err != nil {
			return operations.NewUpdateAppEnvDefault(500).WithPayload(err.Error())
		}

		plugins, err := plugin_service.GetAppPlugins(tx, appID)
		if err != nil {
			return operations.NewUpdateAppEnvDefault(500).WithPayload(err.Error())
		}

		err = app_service.Reload(details, env, plugins)
		if err != nil {
			return operations.NewUpdateAppEnvDefault(500).WithPayload(err.Error())
		}

		return operations.NewUpdateAppEnvOK().WithPayload(env)
	},
)

var UpdateAppTraefikConfig = operations.UpdateAppTraefikConfigHandlerFunc(
	func(params operations.UpdateAppTraefikConfigParams) middleware.Responder {
		log.V("handlers.UpdateAppTraefikConfig()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		err = validation.TraefikPluginConfig(params.NewTraefikConfig)
		if err != nil {
			return operations.NewUpdateAppTraefikConfigBadRequest().WithPayload(err.Error())
		}
		if !plugin_service.IsInstalled(tx, constants.PluginNameTraefik) {
			return operations.NewUpdateAppTraefikConfigBadRequest().WithPayload("Traefik is not installed")
		}

		config := &models.TraefikPluginConfig{
			AppID:       params.AppID,
			Host:        params.NewTraefikConfig.Host,
			Path:        params.NewTraefikConfig.Path,
			TraefikRule: params.NewTraefikConfig.TraefikRule,
		}
		err = plugin_service.UpsertTraefikConfig(tx, config)
		if err != nil {
			return operations.NewUpdateAppTraefikConfigDefault(500).WithPayload(err.Error())
		}

		return operations.NewUpdateAppTraefikConfigOK().WithPayload(config)
	},
)

var UpdateRunConfig = operations.UpdateRunConfigHandlerFunc(
	func(params operations.UpdateRunConfigParams) middleware.Responder {
		log.V("handlers.UpdateRunConfig()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		if err := validation.RunConfig(params.NewRunConfig); err != nil {
			return operations.NewUpdateAppEnvBadRequest().
				WithPayload(err.Error())
		}

		appID, err := app_service.GetAppID(tx, params.AppName)
		if err != nil {
			return operations.NewUpdateRunConfigNotFound().WithPayload(err.Error())
		}

		newRunConfig, err := run_config_service.Get(tx, appID)
		newRunConfig.Command = params.NewRunConfig.Command
		newRunConfig.Networks = params.NewRunConfig.Networks
		newRunConfig.Placement = params.NewRunConfig.Placement
		newRunConfig.PublishedPorts = params.NewRunConfig.PublishedPorts
		newRunConfig.TargetPorts = params.NewRunConfig.TargetPorts
		newRunConfig.Volumes = params.NewRunConfig.Volumes
		err = run_config_service.Upsert(tx, newRunConfig)
		if err != nil {
			return operations.NewUpdateRunConfigDefault(500).WithPayload(err.Error())
		}

		details, err := app_service.Details(tx, params.AppName)
		if err != nil {
			return operations.NewUpdateRunConfigNotFound().WithPayload(err.Error())
		}

		env, err := env_service.Get(tx, appID)
		if err != nil {
			return operations.NewUpdateAppEnvDefault(500).WithPayload(err.Error())
		}

		plugins, err := plugin_service.GetAppPlugins(tx, appID)
		if err != nil {
			return operations.NewUpdateAppEnvDefault(500).WithPayload(err.Error())
		}

		err = app_service.Reload(details, env, plugins)
		if err != nil {
			return operations.NewUpdateAppEnvDefault(500).WithPayload(err.Error())
		}

		return operations.NewUpdateRunConfigOK().WithPayload(details.RunConfig)
	},
)

var UpgradeApp = operations.UpgradeAppHandlerFunc(
	func(params operations.UpgradeAppParams) middleware.Responder {
		log.V("handlers.UpgradeApp()")
		var err error
		tx, onDefer := database.TX(&err)
		defer onDefer()

		details, err := app_service.Details(tx, params.AppName)
		if err != nil {
			return operations.NewUpgradeAppNotFound().WithPayload(err.Error())
		}
		appId := details.App.ID.String()
		env, err := env_service.Get(tx, appId)
		if err != nil {
			return operations.NewUpgradeAppDefault(500).WithPayload(err.Error())
		}
		plugins, err := plugin_service.GetAppPlugins(tx, appId)
		if err != nil {
			return operations.NewUpgradeAppDefault(500).WithPayload(err.Error())
		}

		var newImage string
		if params.NewImage == nil {
			newImage = details.App.Image
		} else {
			newImage = *params.NewImage
		}
		updated, err := app_service.Upgrade(tx, details, env, plugins, newImage)

		if err != nil {
			return operations.NewUpgradeAppDefault(500).WithPayload(err.Error())
		}
		if !updated {
			return operations.NewUpgradeAppBadRequest().WithPayload(fmt.Sprintf("No updates are available for %s!", newImage))
		}
		return operations.NewUpgradeAppNoContent()
	},
)