// src/hooks/use-checklist-state.ts
"use client";

import { useCallback, useEffect, useState } from "react";

// Per-site storage so manual check-offs don't bleed across sites. No migration
// from the old global `flight-checker:checked` key — scoping starts going forward.
const STORAGE_PREFIX = "flight-checker:checked";

function storageKey(siteId: string) {
  return `${STORAGE_PREFIX}:${siteId}`;
}

type CheckedMap = Record<string, true>;

function read(siteId: string): CheckedMap {
  if (typeof window === "undefined" || !siteId) return {};
  try {
    const raw = window.localStorage.getItem(storageKey(siteId));
    return raw ? (JSON.parse(raw) as CheckedMap) : {};
  } catch {
    return {};
  }
}

export type ChecklistState = {
  /** true tant que le state localStorage n'est pas hydraté (rendu serveur). */
  hydrating: boolean;
  isChecked: (id: string) => boolean;
  toggle: (id: string) => void;
  reset: () => void;
  /** done/total ; calcule la progression sur les ids passés. */
  progress: (ids: string[]) => { done: number; total: number };
};

export function useChecklistState(siteId: string): ChecklistState {
  const [checked, setChecked] = useState<CheckedMap>({});
  const [hydrating, setHydrating] = useState(true);

  // Hydratation après montage, et re-hydratation au changement de site →
  // pas de mismatch SSR, et chaque site garde ses propres cases.
  useEffect(() => {
    setHydrating(true);
    setChecked(read(siteId));
    setHydrating(false);
  }, [siteId]);

  const persist = useCallback(
    (next: CheckedMap) => {
      setChecked(next);
      if (!siteId) return;
      try {
        window.localStorage.setItem(storageKey(siteId), JSON.stringify(next));
      } catch {
        // quota / mode privé : on garde l'état en mémoire.
      }
    },
    [siteId],
  );

  const isChecked = useCallback(
    (id: string) => checked[id] === true,
    [checked],
  );

  const toggle = useCallback(
    (id: string) => {
      const next = { ...checked };
      if (next[id]) delete next[id];
      else next[id] = true;
      persist(next);
    },
    [checked, persist],
  );

  const reset = useCallback(() => persist({}), [persist]);

  const progress = useCallback(
    (ids: string[]) => ({
      done: ids.reduce((n, id) => (checked[id] ? n + 1 : n), 0),
      total: ids.length,
    }),
    [checked],
  );

  return { hydrating, isChecked, toggle, reset, progress };
}