warpbox-dev/backend/libs/config/config.go

package config

import (
	"fmt"
	"math"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

type Config struct {
	AppName          string
	Environment      string
	Addr             string
	BaseURL          string
	DataDir          string
	AdminToken       string
	StaticDir        string
	TemplateDir      string
	ReadTimeout      time.Duration
	WriteTimeout     time.Duration
	IdleTimeout      time.Duration
	JobsEnabled      bool
	CleanupEnabled   bool
	CleanupEvery     time.Duration
	ThumbnailEnabled bool
	ThumbnailEvery   time.Duration
	MaxUploadSize    int64
}

func Load() (Config, error) {
	cfg := Config{
		AppName:          envString("WARPBOX_APP_NAME", "warpbox.dev"),
		Environment:      envString("WARPBOX_ENV", "development"),
		Addr:             envString("WARPBOX_ADDR", ":8080"),
		BaseURL:          strings.TrimRight(envString("WARPBOX_BASE_URL", "http://localhost:8080"), "/"),
		DataDir:          envString("WARPBOX_DATA_DIR", defaultPath("data")),
		AdminToken:       envString("WARPBOX_ADMIN_TOKEN", ""),
		StaticDir:        envString("WARPBOX_STATIC_DIR", defaultPath("static")),
		TemplateDir:      envString("WARPBOX_TEMPLATE_DIR", defaultPath("templates")),
		ReadTimeout:      envDuration("WARPBOX_READ_TIMEOUT", 15*time.Second),
		WriteTimeout:     envDuration("WARPBOX_WRITE_TIMEOUT", 60*time.Second),
		IdleTimeout:      envDuration("WARPBOX_IDLE_TIMEOUT", 120*time.Second),
		JobsEnabled:      envBool("WARPBOX_JOBS_ENABLED", true),
		CleanupEnabled:   envBool("WARPBOX_CLEANUP_ENABLED", true),
		CleanupEvery:     envDuration("WARPBOX_CLEANUP_EVERY", time.Hour),
		ThumbnailEnabled: envBool("WARPBOX_THUMBNAIL_ENABLED", true),
		ThumbnailEvery:   envDuration("WARPBOX_THUMBNAIL_EVERY", time.Minute),
		MaxUploadSize:    envMegabytes("WARPBOX_MAX_UPLOAD_SIZE_MB", 2048), // 2 GiB default.
	}

	if cfg.BaseURL == "" {
		return Config{}, fmt.Errorf("WARPBOX_BASE_URL cannot be empty")
	}
	if cfg.MaxUploadSize <= 0 {
		return Config{}, fmt.Errorf("WARPBOX_MAX_UPLOAD_SIZE_MB must be positive")
	}

	return cfg, nil
}

func defaultPath(name string) string {
	candidates := []string{
		filepath.Join("backend", name),
		name,
	}

	for _, candidate := range candidates {
		if info, err := os.Stat(candidate); err == nil && info.IsDir() {
			return candidate
		}
	}

	return filepath.Join("backend", name)
}

func envString(key, fallback string) string {
	if value := strings.TrimSpace(os.Getenv(key)); value != "" {
		return value
	}
	return fallback
}

func envDuration(key string, fallback time.Duration) time.Duration {
	value := strings.TrimSpace(os.Getenv(key))
	if value == "" {
		return fallback
	}

	parsed, err := time.ParseDuration(value)
	if err != nil {
		return fallback
	}
	return parsed
}

func envBool(key string, fallback bool) bool {
	value := strings.TrimSpace(os.Getenv(key))
	if value == "" {
		return fallback
	}

	parsed, err := strconv.ParseBool(value)
	if err != nil {
		return fallback
	}
	return parsed
}

func envMegabytes(key string, fallback float64) int64 {
	value := strings.TrimSpace(os.Getenv(key))
	if value == "" {
		return megabytesToBytes(fallback)
	}

	parsed, err := parseMegabytes(value)
	if err != nil {
		return megabytesToBytes(fallback)
	}
	return parsed
}

func parseMegabytes(value string) (int64, error) {
	normalized := strings.TrimSpace(value)
	normalized = strings.TrimSuffix(normalized, "MB")
	normalized = strings.TrimSuffix(normalized, "Mb")
	normalized = strings.TrimSuffix(normalized, "mb")
	normalized = strings.TrimSpace(normalized)

	sizeMB, err := strconv.ParseFloat(normalized, 64)
	if err != nil {
		return 0, fmt.Errorf("invalid megabyte value %q: %w", value, err)
	}
	if sizeMB <= 0 {
		return 0, fmt.Errorf("megabyte value must be positive")
	}

	return megabytesToBytes(sizeMB), nil
}

func megabytesToBytes(sizeMB float64) int64 {
	return int64(math.Round(sizeMB * 1024 * 1024))
}