// ============================================================
// AuthProvider + useAuth — controla login, cadastro e favoritos
// ============================================================
// - Token JWT-like (random hex) é guardado em localStorage 'lua_token'
// - Ao montar, valida o token chamando GET /api/auth/me
// - Expõe: user, token, favorites, login, signup, logout, toggleFavorite
// - Gerencia o LoginModal global (open/close + "intent" pós-login)
// - Flash messages (toast) compartilhado

const AuthContext = createContext(null);

const TOKEN_KEY = 'lua_token';

function AuthProvider({ children }) {
  const [user, setUser]         = useState(null);
  const [token, setToken]       = useState(() => {
    try { return localStorage.getItem(TOKEN_KEY) || null; } catch(e){ return null; }
  });
  const [loading, setLoading]   = useState(!!token);
  const [modalOpen, setModalOpen] = useState(false);
  const [modalMsg, setModalMsg]   = useState(null);
  // intent: { type:'favorite', productId } — coisa a fazer DEPOIS de logar
  const [intent, setIntent]     = useState(null);
  // toast simples (auto-some em 3s)
  const [toast, setToast]       = useState(null);

  const favorites = Array.isArray(user?.favorites) ? user.favorites : [];

  function flash(message, kind = 'info'){
    setToast({ message, kind, id: Date.now() });
    setTimeout(()=> setToast(t => (t && t.id === Date.now()) ? null : t), 3200);
    // safer: clear after delay regardless
    setTimeout(()=> setToast(null), 3300);
  }

  // Salva/limpa token em localStorage
  function persistToken(t){
    try {
      if (t) localStorage.setItem(TOKEN_KEY, t);
      else   localStorage.removeItem(TOKEN_KEY);
    } catch(e){}
  }

  function setAuth(newToken, newUser){
    setToken(newToken);
    setUser(newUser);
    persistToken(newToken);
  }

  // ---------- API helpers ----------
  async function api(path, opts = {}){
    const headers = { 'Content-Type': 'application/json', ...(opts.headers || {}) };
    if (token) headers['Authorization'] = 'Bearer ' + token;
    const r = await fetch(path, { ...opts, headers });
    const isJson = r.headers.get('content-type')?.includes('json');
    const data = isJson ? await r.json().catch(()=> ({})) : null;
    if (!r.ok) {
      const err = new Error((data && data.message) || ('HTTP ' + r.status));
      err.status = r.status;
      err.data = data;
      throw err;
    }
    return data;
  }

  // ---------- Hidrata user a partir do token ao carregar ----------
  useEffect(() => {
    let cancel = false;
    if (!token) { setLoading(false); }
    else {
      fetch('/api/auth/me', { headers: { 'Authorization': 'Bearer ' + token } })
        .then(r => r.ok ? r.json() : null)
        .then(data => {
          if (cancel) return;
          if (data && data.user) setUser(data.user);
          else { setAuth(null, null); }
        })
        .catch(()=> {})
        .finally(()=> { if (!cancel) setLoading(false); });
    }

    // Se a URL tem #login (vinda de outras páginas), abre o modal.
    if (location.hash === '#login') {
      setModalOpen(true);
      // limpa pra não reabrir em refreshes
      history.replaceState(null, '', location.pathname + location.search);
    }

    // Se outra página deixou um favorito pendente (ex: detalhe do produto
    // clicou no coração deslogado), pega aqui e prepara pra salvar depois
    // que o usuário logar.
    try {
      const pend = sessionStorage.getItem('lua_pending_fav');
      if (pend) {
        sessionStorage.removeItem('lua_pending_fav');
        setIntent({ type: 'favorite', productId: pend });
        setModalMsg('Crie sua conta pra salvar essa peça nos favoritos.');
        setModalOpen(true);
      }
    } catch(e){}

    return () => { cancel = true; };
    // eslint-disable-next-line
  }, []);

  // ---------- Login / signup ----------
  async function login(email, password){
    try {
      const data = await api('/api/auth/login', {
        method: 'POST',
        body: JSON.stringify({ email, password }),
      });
      setAuth(data.token, data.user);
      flash('Bem-vinda de volta, ' + (data.user.name || '').split(' ')[0] + '!', 'success');
      await runIntent(data.token, data.user);
      setModalOpen(false);
      return data.user;
    } catch (err) {
      // Erro especial: email não verificado → propaga com info pra UI mostrar resend
      if (err?.data?.error === 'email_not_verified') {
        const ex = new Error(err.data.message);
        ex.code = 'email_not_verified';
        ex.email = err.data.email || email;
        throw ex;
      }
      throw err;
    }
  }

  async function signup(name, email, password, recaptchaToken){
    const data = await api('/api/auth/signup', {
      method: 'POST',
      body: JSON.stringify({ name, email, password, recaptchaToken }),
    });
    // Não logamos automaticamente — usuário precisa confirmar email primeiro.
    return { requiresVerification: true, email: data.email || email };
  }

  async function resendVerification(email){
    return api('/api/auth/resend-verification', {
      method: 'POST',
      body: JSON.stringify({ email }),
    });
  }

  async function logout(){
    try {
      if (token) await fetch('/api/auth/me', {
        method: 'DELETE',
        headers: { 'Authorization': 'Bearer ' + token },
      });
    } catch(e){}
    setAuth(null, null);
    flash('Você saiu da sua conta.', 'info');
  }

  // ---------- Favoritos ----------
  async function toggleFavorite(productId, productName){
    if (!user || !token) {
      // pede pra logar; depois aplica o favorito
      setIntent({ type: 'favorite', productId, productName });
      setModalMsg('Crie sua conta pra salvar essa peça nos favoritos.');
      setModalOpen(true);
      return { ok: false, needsAuth: true };
    }
    return doToggleFavorite(productId, productName, token);
  }

  async function doToggleFavorite(productId, productName, useToken){
    try {
      const r = await fetch('/api/favorites', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer ' + useToken,
        },
        body: JSON.stringify({ productId, action: 'toggle' }),
      });
      const data = await r.json().catch(()=> ({}));
      if (!r.ok) throw new Error(data.message || 'Falha ao salvar favorito.');

      // Atualiza user.favorites local
      setUser(u => u ? { ...u, favorites: data.favorites } : u);

      if (data.added) {
        flash((productName ? '“' + productName + '” salvo' : 'Salvo') + ' nos seus favoritos ❤', 'success');
      } else {
        flash((productName ? '“' + productName + '” removido' : 'Removido') + ' dos favoritos.', 'info');
      }
      return { ok: true, added: data.added };
    } catch (e) {
      flash(e.message || 'Não foi possível salvar agora.', 'error');
      return { ok: false, error: e.message };
    }
  }

  // Depois de logar com sucesso, executa o que o usuário queria fazer
  async function runIntent(useToken, useUser){
    const i = intent;
    if (!i) return;
    setIntent(null);
    setModalMsg(null);
    if (i.type === 'favorite' && i.productId) {
      // garante que ainda não está nos favoritos (signup novo == vazio)
      const already = (useUser?.favorites || []).includes(i.productId);
      if (!already) {
        await doToggleFavorite(i.productId, i.productName, useToken);
      }
    }
  }

  function openLogin(message){
    setModalMsg(message || null);
    setModalOpen(true);
  }
  function closeLogin(){
    setModalOpen(false);
    setModalMsg(null);
    setIntent(null);
  }

  const value = {
    user, token, loading, favorites,
    isLoggedIn: !!user,
    isAdmin: user?.role === 'admin',
    login, signup, logout, toggleFavorite, resendVerification,
    isFavorite: (productId) => favorites.includes(productId),
    modalOpen, modalMsg, openLogin, closeLogin,
    toast,
  };

  return (
    <AuthContext.Provider value={value}>
      {children}
      <AuthToast toast={toast}/>
    </AuthContext.Provider>
  );
}

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

// ----- Toast visual (canto inferior central) -----
function AuthToast({ toast }) {
  if (!toast) return null;
  const colors = {
    success: { bg: '#0e7490', icon: '✓' },
    error:   { bg: '#b91c3c', icon: '!' },
    info:    { bg: '#1f2a30', icon: 'ℹ' },
  };
  const c = colors[toast.kind] || colors.info;
  return (
    <div style={{
      position: 'fixed', bottom: 28, left: '50%',
      transform: 'translateX(-50%)',
      zIndex: 200,
      background: c.bg, color: 'white',
      padding: '14px 22px',
      borderRadius: 999,
      fontSize: 14, fontWeight: 500,
      boxShadow: '0 20px 40px -12px rgba(8,51,68,0.45)',
      display: 'inline-flex', alignItems: 'center', gap: 10,
      animation: 'toast-in .25s ease',
      maxWidth: 'min(420px, 92vw)',
    }}>
      <span style={{
        width: 22, height: 22, borderRadius: '50%',
        background: 'rgba(255,255,255,0.2)',
        display: 'inline-flex', alignItems: 'center', justifyContent: 'center',
        fontSize: 12, fontWeight: 700,
      }}>{c.icon}</span>
      {toast.message}
      <style>{`
        @keyframes toast-in {
          from { opacity: 0; transform: translate(-50%, 10px); }
          to   { opacity: 1; transform: translate(-50%, 0); }
        }
      `}</style>
    </div>
  );
}

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