// ============ Auth context + state ============
const AUTH_KEY = 'edgebook:auth';
const SESSION_KEY = 'edgebook:session';

const AuthContext = React.createContext({
  user: null,
  signIn: () => {},
  signUp: () => {},
  signOut: () => {},
  deleteAccount: () => {},
  requestReset: () => {},
  resetPassword: () => {},
  verifyEmail: () => {},
});

const loadUser = () => {
  try {
    const raw = localStorage.getItem(SESSION_KEY);
    return raw ? JSON.parse(raw) : null;
  } catch { return null; }
};

const AuthProvider = ({ children }) => {
  const [user, setUser] = useState(() => loadUser());
  const [authRoute, setAuthRoute] = useState('login'); // login | signup | forgot | reset | verify
  const [pendingEmail, setPendingEmail] = useState('');

  const persist = (u) => {
    try {
      if (u) localStorage.setItem(SESSION_KEY, JSON.stringify(u));
      else localStorage.removeItem(SESSION_KEY);
    } catch {}
    setUser(u);
  };

  const signIn = (email, password) => {
    // Mock: accept any non-empty credentials
    if (!email || !password) return { error: 'empty' };
    const u = { email, name: email.split('@')[0], verified: true, createdAt: Date.now() };
    persist(u);
    return { ok: true };
  };

  const signUp = (name, email, password) => {
    if (!name || !email || !password) return { error: 'empty' };
    // Go to verify step
    setPendingEmail(email);
    setAuthRoute('verify');
    // Stash pending signup in localStorage so verify can finalize
    try { localStorage.setItem('edgebook:pending', JSON.stringify({ name, email })); } catch {}
    return { ok: true };
  };

  const verifyEmail = (code) => {
    if (!code || code.length < 6) return { error: 'invalid' };
    try {
      const p = JSON.parse(localStorage.getItem('edgebook:pending') || '{}');
      if (p.email) {
        const u = { email: p.email, name: p.name || p.email.split('@')[0], verified: true, createdAt: Date.now() };
        persist(u);
        localStorage.removeItem('edgebook:pending');
        try { localStorage.setItem('edgebook:onboarded', 'false'); } catch {}
        return { ok: true, needsOnboarding: true };
      }
    } catch {}
    return { error: 'invalid' };
  };

  const signOut = () => {
    persist(null);
    setAuthRoute('login');
  };

  const deleteAccount = () => {
    try {
      // Wipe ALL edgebook state
      const keys = [];
      for (let i=0;i<localStorage.length;i++){
        const k = localStorage.key(i);
        if (k && k.startsWith('edgebook:')) keys.push(k);
      }
      keys.forEach(k => localStorage.removeItem(k));
    } catch {}
    setUser(null);
    setAuthRoute('signup');
  };

  const requestReset = (email) => {
    if (!email) return { error: 'empty' };
    setPendingEmail(email);
    setAuthRoute('reset');
    return { ok: true };
  };

  const resetPassword = (code, newPassword) => {
    if (!code || code.length < 6 || !newPassword) return { error: 'invalid' };
    setAuthRoute('login');
    return { ok: true };
  };

  return (
    <AuthContext.Provider value={{
      user, authRoute, setAuthRoute, pendingEmail, setPendingEmail,
      signIn, signUp, signOut, deleteAccount, requestReset, resetPassword, verifyEmail,
    }}>
      {children}
    </AuthContext.Provider>
  );
};

const useAuth = () => React.useContext(AuthContext);

Object.assign(window, { AuthContext, AuthProvider, useAuth });