/* === Supabase client + auth/data hooks ===
   - Initializes the global Supabase JS client.
   - useSupabaseSession(): tracks auth state. Returns undefined while loading,
     null when signed out, or the session object when signed in.
   - useHouseholdState(session): loads the caller's household row, exposes
     a setState that debounce-saves to Supabase, and subscribes to realtime
     changes so other devices auto-sync.
*/

const SUPABASE_URL = 'https://hgfkjgdixomaxdyrushk.supabase.co';
const SUPABASE_KEY = 'sb_publishable_YzcvCVgwkCvJVbVtIA5XdA_3DEihCHD';

const supabaseClient = window.supabase.createClient(SUPABASE_URL, SUPABASE_KEY);

function useSupabaseSession() {
  const [session, setSession] = React.useState(undefined);

  React.useEffect(() => {
    let cancelled = false;
    supabaseClient.auth.getSession().then(({ data }) => {
      if (!cancelled) setSession(data.session);
    });
    const { data: sub } = supabaseClient.auth.onAuthStateChange((_event, s) => {
      if (!cancelled) setSession(s);
    });
    return () => { cancelled = true; sub.subscription.unsubscribe(); };
  }, []);

  return session;
}

function useHouseholdState(session) {
  const [state, setStateInternal] = React.useState(undefined);
  const [householdId, setHouseholdId] = React.useState(null);
  const [error, setError] = React.useState(null);
  const stateRef = React.useRef(null);
  const saveTimerRef = React.useRef(null);
  const savingRef = React.useRef(false);

  // Initial load
  React.useEffect(() => {
    if (!session) return;
    let cancelled = false;
    (async () => {
      const { data, error } = await supabaseClient
        .from('households')
        .select('id, state')
        .contains('member_ids', [session.user.id])
        .limit(1)
        .maybeSingle();
      if (cancelled) return;
      if (error) { setError(error.message); return; }
      if (!data) { setError('No household row found for your account. Contact the household admin to be added.'); return; }
      const merged = { ...INITIAL_STATE, ...(data.state || {}) };
      stateRef.current = merged;
      setHouseholdId(data.id);
      setStateInternal(merged);
    })();
    return () => { cancelled = true; };
  }, [session?.user?.id]);

  // Realtime: skip echoes of our own writes (savingRef / saveTimerRef as a guard).
  React.useEffect(() => {
    if (!householdId) return;
    const channel = supabaseClient
      .channel(`household:${householdId}`)
      .on('postgres_changes',
          { event: 'UPDATE', schema: 'public', table: 'households', filter: `id=eq.${householdId}` },
          (payload) => {
            if (savingRef.current || saveTimerRef.current) return;
            const merged = { ...INITIAL_STATE, ...(payload.new.state || {}) };
            stateRef.current = merged;
            setStateInternal(merged);
          })
      .subscribe();
    return () => { supabaseClient.removeChannel(channel); };
  }, [householdId]);

  // setState wrapper: updates local state immediately, debounce-saves to Supabase.
  const setState = React.useCallback((updater) => {
    setStateInternal(prev => {
      const next = typeof updater === 'function' ? updater(prev) : updater;
      stateRef.current = next;
      if (saveTimerRef.current) clearTimeout(saveTimerRef.current);
      saveTimerRef.current = setTimeout(async () => {
        saveTimerRef.current = null;
        if (!householdId) return;
        savingRef.current = true;
        const { error } = await supabaseClient
          .from('households')
          .update({ state: stateRef.current, updated_at: new Date().toISOString() })
          .eq('id', householdId);
        savingRef.current = false;
        if (error) setError(error.message); else setError(null);
      }, 500);
      return next;
    });
  }, [householdId]);

  const signOut = React.useCallback(() => supabaseClient.auth.signOut(), []);

  return { state, setState, error, signOut };
}

Object.assign(window, { supabaseClient, useSupabaseSession, useHouseholdState });