EpicNext-Cms/src/lib/services/site-settings.ts

import "server-only";

import { prisma } from "@/lib/prisma";
import { redis } from "@/lib/redis";

const DEFAULTS: Record<string, string> = {
	hotel_name: "Atom",
	habbo_imaging_url: "/imaging",
	logo_url: "",
	nitro_client_url: "",
	habbo_gamedata_hotel: "it",
};

const CACHE_TTL_MS = 300_000;
const REDIS_CACHE_KEY = "site_settings";

class SiteSettings {
	private cache: Map<string, string> | null = null;

	private async loadFromDb(): Promise<Map<string, string>> {
		try {
			const rows = await prisma.websiteSetting.findMany({
				select: { key: true, value: true },
			});
			return new Map(rows.map((r) => [r.key, r.value]));
		} catch {
			return new Map(Object.entries(DEFAULTS));
		}
	}

	private async load(): Promise<Map<string, string>> {
		if (redis) {
			try {
				const cached = await redis.get(REDIS_CACHE_KEY);
				if (cached) {
					const parsed = JSON.parse(cached) as Record<string, string>;
					return new Map(Object.entries(parsed));
				}
			} catch {
				// Redis unavailable — fall through
			}
		}

		if (this.cache !== null) return this.cache;

		const map = await this.loadFromDb();
		this.cache = map;

		if (redis) {
			try {
				const obj = Object.fromEntries(map.entries());
				await redis.setex(
					REDIS_CACHE_KEY,
					Math.ceil(CACHE_TTL_MS / 1000),
					JSON.stringify(obj),
				);
			} catch {
				// non-critical
			}
		}

		return map;
	}

	async get(
		key: string,
		fallback: string | null = null,
	): Promise<string | null> {
		const map = await this.load();
		if (map.has(key)) return map.get(key) as string;
		// eslint-disable-next-line security/detect-object-injection -- guarded by `key in DEFAULTS`
		if (key in DEFAULTS) return DEFAULTS[key] as string;
		return fallback;
	}

	async getBool(key: string, fallback = false): Promise<boolean> {
		const v = await this.get(key, null);
		if (v === null) return fallback;
		const s = v.toLowerCase();
		return s === "1" || s === "true";
	}

	async update(key: string, value: string): Promise<void> {
		await prisma.websiteSetting.upsert({
			where: { key },
			create: { key, value },
			update: { value },
		});
		await this.reload();
	}

	async reload(): Promise<void> {
		this.cache = null;
		if (redis) {
			try {
				await redis.del(REDIS_CACHE_KEY);
			} catch {
				// non-critical
			}
		}
	}
}

export const siteSettings = new SiteSettings();