// Code generated by go-swagger/go-orusapi; DO NOT EDIT.

{{ if .Copyright -}}// {{ comment .Copyright -}}{{ end }}

{{- $noDB := not (not (index .Info.Extensions "x-go-orusapi-no-db") ) }}

package cmd

import (
	"github.com/dlmiddlecote/sqlstats"
	"github.com/go-openapi/loads"
	"github.com/jmoiron/sqlx"
	flags "github.com/orus-io/go-flags"
	"github.com/prometheus/client_golang/prometheus"
	orusapi "orus.io/orus-io/go-orusapi"
	{{- if not $noDB }}
    "orus.io/orus-io/go-orusapi/database"
    {{- end }}
	"{{ joinFilePath .TargetImportPath "restapi" "operations" }}"
)

// NewServerCmd creates a ServerCmd
func NewServerCmd() *ServeCmd {
	swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
	if err != nil {
		Logger.Fatal().Err(err).Msg("")
	}
	api := operations.New{{ pascalize .Name }}API(swaggerSpec)
	server := orusapi.NewServer(nil)

	cmd := ServeCmd{
		Server:       server,
		API:          api,
	}

	return &cmd
}

// ServeCmd is the 'serve' command
type ServeCmd struct {
	Server *orusapi.Server

	{{- if not $noDB }}
	AutoMigrate bool `long:"auto-migrate" description:"automatically apply database migrations if needed"`
    {{- end }}

	API     *operations.{{ pascalize .Name }}API `no-flag:"t"`
}

// Execute setup a server and runs it
func (cmd *ServeCmd) Execute([]string) error {
	{{- if not $noDB }}
	if cmd.AutoMigrate {
		if err := database.AutoMigrate(DatabaseOptions.DSN, migration.Source, Logger); err != nil {
			return err
		}
	} else {
		if err := database.IsUptodate(DatabaseOptions.DSN, migration.Source); err != nil {
			return err
		}
	}

	db, err := DatabaseOptions.Open()
	if err != nil {
		return err
	}
	defer func() {
		if err := db.Close(); err != nil {
			Logger.Err(err).Msg("could not close database connection properly")
		}
	}()

	if err := db.Ping(); err != nil {
		return err
	}
    {{- end}}

	if cmd.Server.Prometheus {
		var infoGauge = prometheus.NewGauge(prometheus.GaugeOpts{
			Name: "{{ snakize .Name }}_info",
			Help: "Informations about the {{ pascalize .Name }} server",
			ConstLabels: map[string]string{
				"environment":  InfoOptions.Environment,
				"version":  Version,
			},
		})
		infoGauge.Set(1)
		if err := prometheus.Register(infoGauge); err != nil {
			return err
		}
		defer prometheus.Unregister(infoGauge)

        {{- if not $noDB }}
		collector := sqlstats.NewStatsCollector("db", db)
		if err := prometheus.Register(collector); err != nil {
			return err
		}
		defer prometheus.Unregister(collector)
        {{- end }}
	}

	config := restapi.Config{
		Log: Logger,
        {{- if not $noDB }}
		DB: db,
        {{- end }}
	}
	if err := setupServeConfig(&config); err != nil {
		return err
	}

	cmd.Server.SetLog(Logger)
    cmd.Server.Environment = InfoOptions.Environment

	configuredAPI, err := restapi.ConfigureAPI(cmd.API, cmd.Server, config)
	if err != nil {
		return err
	}

	cmd.Server.SetAPI(configuredAPI)

	defer func() {
		if err := cmd.Server.Shutdown(); err != nil {
			Logger.Err(err).Msg("error shutting down the server")
		}
	}()

	if err := cmd.Server.Serve(); err != nil {
		return err
	}

	return nil
}

func init() {
	var serveCmd = NewServerCmd()
    setupServerCmd(serveCmd)
	serve, err := parser.AddCommand("serve", "Serves the API", "", serveCmd)
	if err != nil {
		Logger.Fatal().Msg(err.Error())
	}

	serve.FindOptionByLongName("socket-path").Default = []string{"/var/run/{{dasherize .Name}}.sock"}

	serve.EnvNamespace = "SERVE"
	serve.FindOptionByLongName("scheme").EnvDefaultKey = "SCHEME"

	for _, optsGroup := range serveCmd.API.CommandLineOptionsGroups {
		_, err := serve.AddGroup(optsGroup.ShortDescription, optsGroup.LongDescription, optsGroup.Options)
		if err != nil {
			Logger.Fatal().Msg(err.Error())
		}
	}
}