import { getPayload } from 'payload';
import { cache } from 'react';
import { getArchiveEntries, resolveRoute as resolveRouteRaw } from '../content/index.js';
import { buildRobots, buildSitemapEntries } from '../seo/index.js';
/**
 * Bundles the per-request data helpers a frontend needs — the same cached
 * wrappers every project was writing by hand (getPayload, settings, locale
 * list, route resolution, archive entries).
 *
 * Everything is wrapped in React `cache()`, so within one request a value is
 * fetched once no matter how many times it's asked for — which matters because
 * Next runs generateMetadata and the page component separately, and both hit
 * these. Crucially the Payload instance is cached *here*, once, so every helper
 * shares it; that's why this is a factory and not loose functions importing a
 * shared module.
 *
 * ```ts
 * // src/lib/content.ts
 * import { createContentHelpers } from 'ipal-kit'
 * import config from '@/payload.config'
 * import { contentConfig } from '@/content.config'
 *
 * export const { getCachedPayload, getSettings, getConfiguredLocales, resolveRoute, getEntries } =
 *   createContentHelpers({ config, content: contentConfig })
 * ```
 *
 * `resolveRoute` and `getEntries` are separate on purpose: routing decides what
 * a URL is, fetching gets the listing. Metadata generation needs the first and
 * not the second, and a page component composes them in two obvious lines.
 */ export function createContentHelpers({ baseUrl, config, content, i18n, pagesSlug = 'pages', settingsSlug = 'site-settings' }) {
    const origin = baseUrl ?? process.env.NEXT_PUBLIC_SERVER_URL ?? '';
    const getCachedPayload = cache(async ()=>getPayload({
            config: await config
        }));
    const getConfiguredLocales = cache(async ()=>{
        const c = await config;
        return c.localization ? c.localization.locales.map((l)=>l.code) : [];
    });
    const getSettings = cache(async (locale)=>{
        const payload = await getCachedPayload();
        return payload.findGlobal({
            slug: settingsSlug,
            depth: 2,
            locale: locale
        });
    });
    /** What does this URL point at? Routing only — no listing data. */ const resolveRoute = cache(async (locale, segments, page)=>{
        const payload = await getCachedPayload();
        return resolveRouteRaw({
            content,
            locale,
            page,
            pagesSlug,
            payload,
            segments,
            settingsSlug
        });
    });
    /** One page of a collection's entries, for an archive listing. */ const getEntries = cache(async (collection, locale, page, perPage)=>{
        const payload = await getCachedPayload();
        return getArchiveEntries({
            collection,
            locale,
            page,
            payload,
            perPage
        });
    });
    /**
   * Ready-made handler for Next's `app/sitemap.ts` — every page and entry with
   * per-URL hreflang and lastmod. Re-export it directly:
   *
   * ```ts
   * // app/sitemap.ts
   * export { sitemap as default } from '@/lib/content'
   * export const dynamic = 'force-dynamic'  // generate at runtime, not build
   * ```
   *
   * IMPORTANT — container deploys (Coolify/Docker/Railway/CI): Next treats
   * sitemap.ts as STATIC by default and prerenders it during `next build`, which
   * calls into Payload → the database. The build container usually has no access
   * to the internal Docker network, so the DB connection fails (ENOTFOUND) and
   * the build dies. Two defenses:
   *   1. `export const dynamic = 'force-dynamic'` in app/sitemap.ts — skips build
   *      prerender, generates at runtime when the DB is reachable (recommended).
   *   2. This handler also catches DB errors and returns [] so that even without
   *      (1) the build won't crash — it just ships an empty sitemap until the
   *      next runtime regeneration. (1) is still preferred; (2) is a safety net.
   */ const sitemap = cache(async ()=>{
        if (!i18n) {
            throw new Error('[ipal] createContentHelpers: pass `i18n` to use the sitemap handler.');
        }
        try {
            return await buildSitemapEntries({
                baseUrl: origin,
                config: i18n,
                content,
                pagesSlug,
                payload: await getCachedPayload(),
                settingsSlug
            });
        } catch (error) {
            // DB unreachable (typically a container build with no DB network) — return
            // an empty sitemap instead of failing the build. Runtime regeneration will
            // produce the real one once the DB is reachable. See dynamic='force-dynamic'.
            console.warn('[ipal] sitemap: could not reach the database, returning empty entries ' + "(add `export const dynamic = 'force-dynamic'` to app/sitemap.ts to " + 'generate at runtime and avoid build-time DB access):', error);
            return [];
        }
    });
    /**
   * Ready-made handler for Next's `app/robots.ts`. Re-export directly:
   *
   * ```ts
   * // app/robots.ts
   * export { robots as default } from '@/lib/content'
   * ```
   */ const robots = ()=>buildRobots({
            baseUrl: origin
        });
    /**
   * Next.js generateStaticParams for the [[...slug]] route (or
   * [locale]/[[...slug]]). Returns every routable page as a params object, so
   * Next PRE-RENDERS them as static (SSG) instead of dynamic.
   *
   * Why this matters beyond convenience: an optional catch-all with no
   * generateStaticParams is treated as a DYNAMIC route (ƒ), which streams
   * metadata into <body> (crawlers miss it). Providing generateStaticParams
   * compiles routes as SSG (●) — the <head> is synchronous and complete. This is
   * the strongest fix for the metadata-in-head problem (stronger than ISR alone).
   *
   * Handles automatically:
   *  - pages collection + content collections (with their archive prefix)
   *  - excludes the homepage (maps to { slug: [] } — the root)
   *  - excludes drafts and 404/500/system slugs
   *  - KEEPS noindex pages (they must still render — noindex controls indexing,
   *    not existence; skipping them would force dynamic rendering)
   *  - localized slugs (string or per-locale map) both handled
   *  - single-locale → { slug }[]; multi-locale → { locale, slug }[]
   *
   * Wire it in the project:
   *   // app/(frontend)/[[...slug]]/page.tsx  (or [locale]/[[...slug]])
   *   export { generateStaticParams } from '@/lib/content'
   */ const generateStaticParams = async ()=>{
        try {
            const payload = await getCachedPayload();
            const locales = i18n ? i18n.locales.map((l)=>l.code) : [
                undefined
            ];
            const singleLocale = !i18n || i18n.locales.length === 1;
            // Home slug per locale, to exclude the homepage (it's the root, slug []).
            const settings = await payload.findGlobal({
                slug: settingsSlug,
                depth: 1,
                locale: 'all'
            }).catch(()=>null);
            const homeId = settings?.homepage?.id;
            const EXCLUDED = new Set([
                '404',
                '500',
                'error',
                'not-found'
            ]);
            const params = [];
            for (const locale of locales){
                // NO where:{_status} filter — collections without drafts enabled don't
                // register the _status field, and querying it throws
                // "path cannot be queried: _status". We filter drafts in memory below,
                // which is safe for every collection (with or without drafts).
                const result = await payload.find({
                    collection: pagesSlug,
                    depth: 0,
                    limit: 1000,
                    locale: locale ?? 'all'
                });
                for (const raw of result.docs){
                    // Draft filter in memory (safe whether or not the collection has drafts).
                    if (raw._status && raw._status !== 'published') {
                        continue;
                    }
                    // NOTE: unlike the sitemap, we do NOT skip meta.noindex here. A noindex
                    // page (privacy, cookies, terms) still needs to render — users reach it
                    // from the footer and crawlers read its <meta robots=noindex>. Pre-render
                    // it as SSG so it's fast and its <head> is complete; noindex controls
                    // INDEXING, not whether the page exists. Skipping it would force dynamic
                    // rendering (the very streaming problem we're avoiding).
                    if (homeId && raw.id === homeId) {
                        // Homepage → root. Emit an empty-slug param so '/' (or '/pl') builds.
                        const empty = singleLocale ? {
                            slug: []
                        } : {
                            slug: [],
                            locale: locale
                        };
                        if (!params.some((p)=>JSON.stringify(p) === JSON.stringify(empty))) {
                            params.push(empty);
                        }
                        continue;
                    }
                    // Slug may be a plain string OR a localized map ({ pl: 'kontakt' }) when
                    // read with locale:'all' or left unflattened. Handle both, or localized
                    // pages get silently dropped.
                    const rawSlug = raw.slug;
                    const slug = typeof rawSlug === 'string' ? rawSlug : rawSlug && typeof rawSlug === 'object' ? rawSlug[locale ?? ''] ?? Object.values(rawSlug)[0] : undefined;
                    if (!slug || EXCLUDED.has(slug)) {
                        continue;
                    }
                    // Multi-level slugs ('atrakcje/telefon') → array segments.
                    const segments = String(slug).split('/').filter(Boolean);
                    params.push(singleLocale ? {
                        slug: segments
                    } : {
                        slug: segments,
                        locale: locale
                    });
                }
            }
            return params;
        } catch (err) {
            // DB unreachable — typically a container build (Docker/Coolify/CI) with no
            // database network. Return [] so the build doesn't crash: Next falls back
            // to on-demand rendering for the routes, which fill in once the DB is
            // reachable at runtime. Without this every project would need its own
            // try/catch here. (Same graceful-degradation as the sitemap handler.)
            console.warn('[ipal] generateStaticParams: database not reachable during build ' + '(Docker/CI) — returning empty params; routes render on-demand at runtime:', err);
            return [];
        }
    };
    return {
        generateStaticParams,
        getCachedPayload,
        getConfiguredLocales,
        getEntries,
        getSettings,
        resolveRoute,
        robots,
        sitemap
    };
}

//# sourceMappingURL=createContentHelpers.js.map