import React from 'react';

type GuestIdentityContextValue = {
  eventKey: string;
  slug: string; // backward-compatible alias
  name: string;
  hydrated: boolean;
  setName: (nextName: string) => void;
  clearName: () => void;
  reload: () => void;
};

const GuestIdentityContext = React.createContext<GuestIdentityContextValue | undefined>(undefined);

function storageKey(eventKey: string) {
  return `guestName_${eventKey}`;
}

export function readGuestName(eventKey: string) {
  if (!eventKey || typeof window === 'undefined') {
    return '';
  }

  try {
    return window.localStorage.getItem(storageKey(eventKey)) ?? '';
  } catch (error) {
    console.warn('Failed to read guest name', error);
    return '';
  }
}

export function GuestIdentityProvider({ eventKey, children }: { eventKey: string; children: React.ReactNode }) {
  const [name, setNameState] = React.useState('');
  const [hydrated, setHydrated] = React.useState(false);

  const loadFromStorage = React.useCallback(() => {
    if (!eventKey) {
      setHydrated(true);
      setNameState('');
      return;
    }

    try {
      const stored = window.localStorage.getItem(storageKey(eventKey));
      setNameState(stored ?? '');
    } catch (error) {
      console.warn('Failed to read guest name from storage', error);
      setNameState('');
    } finally {
      setHydrated(true);
    }
  }, [eventKey]);

  React.useEffect(() => {
    setHydrated(false);
    loadFromStorage();
  }, [loadFromStorage]);

  const persistName = React.useCallback(
    (nextName: string) => {
      const trimmed = nextName.trim();
      setNameState(trimmed);
      try {
        if (trimmed) {
          window.localStorage.setItem(storageKey(eventKey), trimmed);
        } else {
          window.localStorage.removeItem(storageKey(eventKey));
        }
      } catch (error) {
        console.warn('Failed to persist guest name', error);
      }
    },
    [eventKey]
  );

  const clearName = React.useCallback(() => {
    setNameState('');
    try {
      window.localStorage.removeItem(storageKey(eventKey));
    } catch (error) {
      console.warn('Failed to clear guest name', error);
    }
  }, [eventKey]);

  const value = React.useMemo<GuestIdentityContextValue>(
    () => ({
      eventKey,
      slug: eventKey,
      name,
      hydrated,
      setName: persistName,
      clearName,
      reload: loadFromStorage,
    }),
    [eventKey, name, hydrated, persistName, clearName, loadFromStorage]
  );

  return <GuestIdentityContext.Provider value={value}>{children}</GuestIdentityContext.Provider>;
}

export function useGuestIdentity() {
  const ctx = React.useContext(GuestIdentityContext);
  if (!ctx) {
    throw new Error('useGuestIdentity must be used within a GuestIdentityProvider');
  }
  return ctx;
}

export function useOptionalGuestIdentity() {
  return React.useContext(GuestIdentityContext);
}
