main.go

package main

import (
	"context"
	"log/slog"
	"net/http"
	"os"
	"time"

	"archded/internal/config"
	"archded/internal/database"
	"archded/internal/legacy"
	"archded/internal/mirrors"
	"archded/internal/news"
	"archded/internal/packages"
	"archded/internal/popularity"
	"archded/internal/releases"
	"archded/internal/ui"
	"archded/internal/ui/httperror"
	uilayout "archded/internal/ui/layout"
	"archded/internal/web"
)

const defaultCacheMaxAge = 5 * time.Minute

func main() {
	cfg, err := config.Load()
	if err != nil {
		slog.Error("failed to load config", "error", err)
		os.Exit(1)
	}

	if len(os.Args) > 1 {
		os.Exit(runCommand(os.Args[1], cfg))
	}

	if err := run(cfg); err != nil {
		slog.Error("fatal error", "error", err)
		os.Exit(1)
	}
}

func runCommand(cmd string, cfg config.Config) int {
	logger := setupLogger(isDevelopment)
	slog.SetDefault(logger)

	db, err := database.New(cfg.Database)
	if err != nil {
		slog.Error("failed to open database", "error", err)
		return 1
	}
	defer func() { _ = db.Close() }()

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
	defer cancel()

	switch cmd {
	case "update-packages":
		if err := packages.Update(ctx, db, cfg.PackagesMirror); err != nil {
			slog.Error("update-packages failed", "error", err)
			return 1
		}
	case "update-news":
		if err := news.Update(ctx, db); err != nil {
			slog.Error("update-news failed", "error", err)
			return 1
		}
	case "update-mirrors":
		if err := mirrors.Update(ctx, db); err != nil {
			slog.Error("update-mirrors failed", "error", err)
			return 1
		}
	case "update-releases":
		if err := releases.Update(ctx, db); err != nil {
			slog.Error("update-releases failed", "error", err)
			return 1
		}
	case "update-package-popularities":
		if err := popularity.UpdatePackages(ctx, db); err != nil {
			slog.Error("update-package-popularities failed", "error", err)
			return 1
		}
	case "update-mirror-popularities":
		if err := popularity.UpdateMirrors(ctx, db); err != nil {
			slog.Error("update-mirror-popularities failed", "error", err)
			return 1
		}
	default:
		slog.Error("unknown command", "command", cmd) //nolint:gosec // cmd is from os.Args
		return 1
	}

	return 0
}

func run(cfg config.Config) error {
	logger := setupLogger(isDevelopment)
	slog.SetDefault(logger)

	db, err := database.New(cfg.Database)
	if err != nil {
		return err
	}
	defer func() { _ = db.Close() }()

	manifest, err := uilayout.NewManifest(embedManifest)
	if err != nil {
		return err
	}

	mux := http.NewServeMux()

	if err := ui.RegisterRoutes(mux, manifest, db, cfg.DefaultMirror, embedAssets, embedStatic, embedRoot); err != nil {
		return err
	}

	var cacheMiddleware web.Middleware
	if isDevelopment {
		cacheMiddleware = web.NoCache()
	} else {
		cacheMiddleware = web.CacheControl(defaultCacheMaxAge)
	}

	handler := web.Chain(mux,
		web.Recovery(),
		web.SecureHeaders(),
		httperror.Middleware(manifest),
		cacheMiddleware,
		legacy.LegacyMiddleware,
		web.RedirectTrailingSlash(),
	)

	server := web.NewServer(":"+cfg.Port, handler)
	return server.ListenAndServe()
}

func setupLogger(isDevelopment bool) *slog.Logger {
	var handler slog.Handler
	if isDevelopment {
		handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
			Level: slog.LevelDebug,
		})
	} else {
		handler = slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
			Level: slog.LevelWarn,
		})
	}
	return slog.New(handler)
}