package main

import (
	"context"
	"log"
	"os"
	"os/signal"
	"strings"
	"syscall"

	"git.yuntuo.hk/k2safe/go-omni"
	"git.yuntuo.hk/k2safe/go-omni/auth"
	"git.yuntuo.hk/k2safe/go-omni/database"
	"git.yuntuo.hk/k2safe/go-omni/examples/reference/handler"
	"git.yuntuo.hk/k2safe/go-omni/examples/reference/repository"
	"git.yuntuo.hk/k2safe/go-omni/examples/reference/service"
	"git.yuntuo.hk/k2safe/go-omni/logx"

	_ "github.com/go-sql-driver/mysql"
)

func newApp(users service.UserRepository, logger *logx.Logger, options ...omni.Option) *omni.App {
	application := omni.New(options...)
	registerRoutes(application, users, logger, nil, nil)
	return application
}

func newProtectedApp(users service.UserRepository, logger *logx.Logger, authenticator auth.Authenticator, options ...omni.Option) *omni.App {
	application := omni.New(options...)
	registerRoutes(application, users, logger, auth.RequireAuth(authenticator), auth.RequireRole("admin"))
	return application
}

// Registration and business layers are shared by every network adapter.
func registerRoutes(application *omni.App, users service.UserRepository, logger *logx.Logger, write, delete omni.Middleware) {
	application.GET("/health", func(ctx *omni.Context) error {
		return ctx.OK(map[string]string{"status": "ok"})
	})

	api := application.Group("/api/v1", handler.RequestLog(logger))
	handler.NewUsers(service.NewUsers(users)).RegisterRoutes(api, write, delete)
}

func main() {
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()
	if err := runReference(ctx); err != nil {
		log.Fatal(err)
	}
}

func referenceConfig() (omni.Config, error) {
	settings, err := omni.LoadConfig("")
	if err != nil {
		return settings, err
	}
	// Preserve the example's loopback default and legacy address variable.
	if strings.TrimSpace(os.Getenv("GO_OMNI_HTTP_ADDR")) == "" {
		settings.Address = strings.TrimSpace(os.Getenv("GO_OMNI_ADDR"))
		if settings.Address == "" {
			settings.Address = "127.0.0.1:8080"
		}
	}
	if settings.Log.Service == "" {
		settings.Log.Service = "reference-api"
	}
	if settings.Log.Environment == "" {
		settings.Log.Environment = "local"
	}
	if strings.TrimSpace(os.Getenv("GO_OMNI_LOG_OUTPUT")) == "" {
		settings.Log.Output = "stdout"
	}
	return settings, nil
}

func runReference(ctx context.Context) error {
	settings, err := referenceConfig()
	if err != nil {
		return err
	}
	logger, err := logx.New(settings.Log)
	if err != nil {
		return err
	}
	defer logger.Close()
	logx.SetDefault(logger)
	users, closeStorage, storage, err := openUsers(ctx, logger)
	if err != nil {
		return err
	}
	devToken := strings.TrimSpace(os.Getenv("GO_OMNI_DEV_TOKEN"))
	if devToken == "" {
		devToken = "dev-token"
	}
	authenticator := auth.StaticAuthenticator{
		devToken: {UserID: "dev-user", Roles: []string{"admin"}},
	}
	application := newProtectedApp(users, logger, authenticator, omni.WithConfig(settings))
	application.OnShutdown(logger.Close)
	application.OnShutdown(closeStorage)
	logger.Info("starting reference API", "address", settings.Address, "transport", settings.Transport, "tls", settings.TLS.CertFile != "", "storage", storage)
	return application.RunContext(ctx)
}

func openUsers(ctx context.Context, logger *logx.Logger) (service.UserRepository, func() error, string, error) {
	if strings.TrimSpace(os.Getenv("GO_OMNI_DB_DSN")) == "" {
		return repository.NewMemoryUsers(), func() error { return nil }, "memory", nil
	}
	cfg, err := database.ConfigFromEnv("GO_OMNI_DB_")
	if err != nil {
		return nil, nil, "", err
	}
	db, err := database.Open(ctx, cfg)
	if err != nil {
		return nil, nil, "", err
	}
	return repository.NewMySQLUsers(db.DB), db.Close, "mysql", nil
}