package main

import (
	"context"
	"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() {
	logger, err := logx.New(logx.Config{
		Service:     "reference-api",
		Environment: "local",
		Format:      "json",
		Writer:      os.Stdout,
	})
	if err != nil {
		os.Exit(1)
	}
	defer logger.Close()
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()
	users, closeStorage, storage, err := openUsers(ctx, logger)
	if err != nil {
		logger.Error("storage initialization failed", "error", err)
		os.Exit(1)
	}
	defer func() {
		if err := closeStorage(); err != nil {
			logger.Error("storage close failed", "error", 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)
	address := os.Getenv("GO_OMNI_ADDR")
	if address == "" {
		address = "127.0.0.1:8080"
	}
	logger.Info("starting reference API", "address", address, "storage", storage)
	if err := application.RunContext(ctx, address); err != nil {
		logger.Error("server stopped", "error", err)
		os.Exit(1)
	}
}

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
}