import type { MetadataRoute } from "next";

export default function manifest(): MetadataRoute.Manifest {
  return {
    name: "Mon Application",
    short_name: "MonApp",
    description: "Description de mon application",
    start_url: "/",
    display: "standalone",
    background_color: "#ffffff",
    theme_color: "#0C44AA",
    icons: [
      {
        src: "/img/icon-192.png",
        sizes: "192x192",
        type: "image/png",
        purpose: "any",
      },
      {
        src: "/img/icon-512.png",
        sizes: "512x512",
        type: "image/png",
        purpose: "any",
      },
      {
        src: "/img/icon-192.png",
        sizes: "192x192",
        type: "image/png",
        purpose: "maskable",
      },
      {
        src: "/img/icon-512.png",
        sizes: "512x512",
        type: "image/png",
        purpose: "maskable",
      },
    ],
  };
}

const CACHE = "version:2.7.0";
// 1) App shell you want offline without browsing — edit this list
const PRECACHE_URLS = ["/", "/about", "/profil", "/manifest.webmanifest", "/img/logo.png"];
// 2) All GET APIs you want offline without browsing — edit this list
const API_PRECACHE_URLS = ["/api/members", "/api/donations", "/api/activities"];

// Tell every open tab how caching is going: { type, op, done, total, url? }.
// op is "install" (precache) or "warm" (on-demand warm-up).
async function broadcastProgress(msg) {
  try {
    const all = await clients.matchAll({ includeUncontrolled: true, type: "window" });
    all.forEach((client) => client.postMessage(msg));
  } catch {}
}

async function cacheOne(cache, url) {
  try {
    if (url.startsWith("/api")) {
      const res = await fetch(url, { credentials: "include" });
      if (res.ok) await cache.put(url, res.clone());
      return res.ok;
    }
    await cache.add(new Request(url, { cache: "reload" }));
    return true;
  } catch {
    return false;
  }
}

// Sequential caching with progression — failures reported per-url, never block install
async function cacheListWithProgress(cache, urls, op) {
  const total = urls.length;
  let done = 0;
  await broadcastProgress({ type: "CACHE_START", op, done: 0, total });
  for (const url of urls) {
    const ok = await cacheOne(cache, url);
    done += 1;
    await broadcastProgress({ type: "CACHE_PROGRESS", op, done, total, url, ok });
  }
  await broadcastProgress({ type: "CACHE_DONE", op, done, total });
}

self.addEventListener("install", (event) => {
  event.waitUntil(
    (async () => {
      const cache = await caches.open(CACHE);
      await cacheListWithProgress(cache, PRECACHE_URLS, "install");
      if (API_PRECACHE_URLS.length > 0) {
        await cacheListWithProgress(cache, API_PRECACHE_URLS, "warm");
      }
      self.skipWaiting();
    })(),
  );
});

self.addEventListener("activate", (event) => {
  event.waitUntil(Promise.all([clients.claim(), caches.keys().then((keys) => Promise.all(keys.filter((k) => k !== CACHE).map((k) => caches.delete(k))))]));
});

// Warm on demand after login: cacheOfflinePack(...) — same progress protocol
self.addEventListener("message", (event) => {
  if (event.data?.type === "WARM_API_CACHE" && Array.isArray(event.data.urls)) {
    event.waitUntil((async () => {
      const cache = await caches.open(CACHE);
      await cacheListWithProgress(cache, event.data.urls, "warm");
    })());
  }
});

self.addEventListener("fetch", (event) => {
  const { request } = event;
  if (request.method !== "GET") return; // mutations network-only
  const url = new URL(request.url);
  if (url.origin !== self.location.origin) return;
  const isApi = url.pathname.startsWith("/api");
  const isPage = request.mode === "navigate" || request.headers.get("accept")?.includes("text/html");
  event.respondWith((async () => {
    try {
      const response = await fetch(request);
      if (response.ok && (isApi || isPage || response.type === "basic")) {
        const cache = await caches.open(CACHE);
        cache.put(request, response.clone()); // online = always refresh
      }
      return response;
    } catch {
      const cached = await caches.match(request);
      if (cached) return cached;
      if (isPage) { const fallback = await caches.match("/"); if (fallback) return fallback; }
      return new Response("Offline", { status: 503, headers: { "Content-Type": "text/plain" } });
    }
  })());
});

"use client";
import { CacheProgress } from "@ramses1er/cbk-toolkit/client";

// Une fois près de la racine (layout) — apparaît à chaque mise en cache
export default function Layout({ children }) {
  return <>{children}<CacheProgress /></>;
}

"use client";
import { useCacheProgress, warmApiCache } from "@ramses1er/cbk-toolkit/client";

function SyncButton() {
  const { active, done, total, percent } = useCacheProgress();
  return (
    <button
      disabled={active}
      onClick={() => warmApiCache(["/api/members", "/api/donations"], (p) => console.log(p.done + "/" + p.total, p.url))}
    >
      {active ? `Sync… ${done}/${total} (${percent}%)` : "Synchroniser"}
    </button>
  );
}

<CacheProgress
  title="Synchronisation…"
  doneText="Données à jour !"
  hideAfterMs={5000}
  className="max-w-sm"
/>

"use client";
import { cacheOfflinePack } from "@ramses1er/cbk-toolkit/client";

// 1) Déclarez ce qui doit marcher hors-ligne sans visite préalable
const OFFLINE_PACK = {
  pages: ["/", "/profil"],
  apis: ["/api/members", "/api/donations", "/api/activities"],
};

// 2) Un seul appel après login (les pages/APIs peuvent exiger l'auth)
async function handleLoginSuccess() {
  const results = await cacheOfflinePack(OFFLINE_PACK);
  const failed = results.filter((r) => !r.ok);
  if (failed.length > 0) console.warn("Offline incomplet :", failed.map((r) => r.url));
}

import type { NextConfig } from "next";

const nextConfig: NextConfig = {
  async headers() {
    return [
      {
        source: "/sw.js",
        headers: [
          {
            key: "Cache-Control",
            value: "no-cache, no-store, must-revalidate",
          },
          {
            key: "Content-Type",
            value: "application/javascript; charset=utf-8",
          },
        ],
      },
    ];
  },
};

export default nextConfig;

import type { Metadata, Viewport } from "next";
import { InstallPrompt, SwRegistration } from "@ramses1er/cbk-toolkit/client";

export const metadata: Metadata = {
  title: "Mon Application",
  description: "Description de mon application",
  manifest: "/manifest.webmanifest",
  icons: [
    {
      rel: "apple-touch-icon",
      url: "/img/icon-192.png",
      sizes: "192x192",
    },
  ],
  other: {
    "apple-mobile-web-app-capable": "yes",
    "apple-mobile-web-app-status-bar-style": "default",
  },
};

export const viewport: Viewport = {
  themeColor: "#0C44AA",
};

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang="fr">
      <body>
        {children}
        <InstallPrompt appName="Mon Application" />
        <SwRegistration />
      </body>
    </html>
  );
}

export const config = {
  matcher: [
    "/((?!_next/static|_next/image|favicon.ico|img/|manifest|sw).*)",
  ],
};

import { InstallPrompt } from "@ramses1er/cbk-toolkit/client";

export default function RootLayout({ children }) {
  return (
    <>
      {children}
      <InstallPrompt appName="Mon Application" />
      <InstallPrompt
        appName="Mon Application"
        storageKey="ma_app_install_dismissed"
        installText="Installer"
      />
    </>
  );
}

import { SwRegistration } from "@ramses1er/cbk-toolkit/client";

export default function RootLayout({ children }) {
  return (
    <>
      {children}
      <SwRegistration />
      <SwRegistration swUrl="/sw.js" />
    </>
  );
}