| import React, { createContext, useContext, useEffect, useState } from 'react';
|
| import { onAuthStateChanged } from 'firebase/auth';
|
| import {
|
| auth,
|
| signInWithGoogle,
|
| signInWithEmail,
|
| signUpWithEmail,
|
| sendUserEmailVerification,
|
| logOut,
|
| testConnection,
|
| } from '../firebase';
|
|
|
| export interface AppUser {
|
| uid: string;
|
| email: string | null;
|
| displayName: string | null;
|
| photoURL: string | null;
|
| emailVerified: boolean;
|
| }
|
|
|
| interface AuthContextType {
|
| user: AppUser | null;
|
| loading: boolean;
|
| signIn: () => Promise<AppUser>;
|
| signInEmail: (email: string, pass: string) => Promise<AppUser>;
|
| signUpEmail: (email: string, pass: string, name?: string) => Promise<AppUser>;
|
| sendVerificationEmail: () => Promise<void>;
|
| reloadUser: () => Promise<void>;
|
| signOut: () => Promise<void>;
|
| authError: string | null;
|
| clearAuthError: () => void;
|
| }
|
|
|
| const AuthContext = createContext<AuthContextType>({
|
| user: null,
|
| loading: true,
|
| signIn: async () => {
|
| throw new Error('AuthContext not initialized');
|
| },
|
| signInEmail: async () => {
|
| throw new Error('AuthContext not initialized');
|
| },
|
| signUpEmail: async () => {
|
| throw new Error('AuthContext not initialized');
|
| },
|
| sendVerificationEmail: async () => {
|
| throw new Error('AuthContext not initialized');
|
| },
|
| reloadUser: async () => {},
|
| signOut: async () => {},
|
| authError: null,
|
| clearAuthError: () => {},
|
| });
|
|
|
| export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
|
| const [user, setUser] = useState<AppUser | null>(null);
|
| const [loading, setLoading] = useState(true);
|
| const [authError, setAuthError] = useState<string | null>(null);
|
|
|
| useEffect(() => {
|
| testConnection().catch(() => {});
|
|
|
| const unsubscribe = onAuthStateChanged(auth, (firebaseUser) => {
|
| if (firebaseUser) {
|
| const appUser: AppUser = {
|
| uid: firebaseUser.uid,
|
| email: firebaseUser.email,
|
| displayName: firebaseUser.displayName || firebaseUser.email?.split('@')[0] || 'Citizen',
|
| photoURL: firebaseUser.photoURL,
|
| emailVerified: firebaseUser.emailVerified,
|
| };
|
| setUser(appUser);
|
| } else {
|
| setUser(null);
|
| }
|
| setLoading(false);
|
| });
|
|
|
| return () => unsubscribe();
|
| }, []);
|
|
|
| const handleSignInGoogle = async (): Promise<AppUser> => {
|
| setAuthError(null);
|
| try {
|
| const loggedUser = await signInWithGoogle();
|
| const appUser: AppUser = {
|
| uid: loggedUser.uid,
|
| email: loggedUser.email,
|
| displayName: loggedUser.displayName || 'Citizen',
|
| photoURL: loggedUser.photoURL,
|
| emailVerified: loggedUser.emailVerified,
|
| };
|
| setUser(appUser);
|
| return appUser;
|
| } catch (err: any) {
|
| console.error('Google sign-in error:', err);
|
| let message = 'Google sign-in could not be completed.';
|
|
|
| if (err?.code === 'auth/unauthorized-domain') {
|
| message =
|
| 'This domain is not yet authorized for Google Sign-In in Firebase. Please use Email Login below, or add this domain in Firebase Console > Authentication > Settings > Authorized Domains.';
|
| } else if (err?.code === 'auth/popup-blocked') {
|
| message = 'Google sign-in popup was blocked by your browser. Please allow popups or use Email Login.';
|
| } else if (err?.code === 'auth/cancelled-popup-request' || err?.code === 'auth/popup-closed-by-user') {
|
| message = 'The Google sign-in window was closed before completing.';
|
| } else if (err?.message) {
|
| message = err.message;
|
| }
|
| setAuthError(message);
|
| throw new Error(message);
|
| }
|
| };
|
|
|
| const handleSignInEmail = async (email: string, pass: string): Promise<AppUser> => {
|
| setAuthError(null);
|
| try {
|
| const loggedUser = await signInWithEmail(email, pass);
|
|
|
|
|
| if (!loggedUser.emailVerified) {
|
|
|
| try {
|
| await sendUserEmailVerification(loggedUser);
|
| } catch (vErr) {
|
| console.warn('Could not auto-resend verification on login attempt:', vErr);
|
| }
|
| await logOut();
|
| setUser(null);
|
| const unverifiedError: any = new Error(
|
| 'Email verification required. We have sent a verification link to your email. Please click the link to verify your account before logging in.'
|
| );
|
| unverifiedError.code = 'auth/unverified-email';
|
| throw unverifiedError;
|
| }
|
|
|
| const appUser: AppUser = {
|
| uid: loggedUser.uid,
|
| email: loggedUser.email,
|
| displayName: loggedUser.displayName || email.split('@')[0],
|
| photoURL: loggedUser.photoURL,
|
| emailVerified: loggedUser.emailVerified,
|
| };
|
| setUser(appUser);
|
| return appUser;
|
| } catch (err: any) {
|
| console.error('Email sign-in error:', err);
|
| let message = 'Could not sign in with this email and password.';
|
| if (err?.code === 'auth/unverified-email') {
|
| message = err.message;
|
| } else if (err?.code === 'auth/operation-not-allowed') {
|
| message =
|
| 'Email/Password provider is not enabled in Firebase Console. Go to Firebase Console > Authentication > Sign-in method > Enable "Email/Password", or click "Continue with Google".';
|
| } else if (
|
| err?.code === 'auth/user-not-found' ||
|
| err?.code === 'auth/wrong-password' ||
|
| err?.code === 'auth/invalid-credential'
|
| ) {
|
| message = 'Invalid email or password. If you do not have an account yet, click "Create Account".';
|
| } else if (err?.code === 'auth/invalid-email') {
|
| message = 'Please enter a valid email address.';
|
| } else if (err?.message) {
|
| message = err.message;
|
| }
|
| setAuthError(message);
|
| throw new Error(message);
|
| }
|
| };
|
|
|
| const handleSignUpEmail = async (email: string, pass: string, name?: string): Promise<AppUser> => {
|
| setAuthError(null);
|
| try {
|
| const loggedUser = await signUpWithEmail(email, pass, name);
|
|
|
|
|
| try {
|
| await sendUserEmailVerification(loggedUser);
|
| } catch (verifErr: any) {
|
| console.warn('Auto verification email notice:', verifErr);
|
| }
|
|
|
|
|
| await logOut();
|
| setUser(null);
|
|
|
| const verificationNeeded: any = new Error(
|
| `Account created for ${email}! A verification link has been sent to your email inbox. Please verify your email before signing in.`
|
| );
|
| verificationNeeded.code = 'auth/verification-sent';
|
| throw verificationNeeded;
|
| } catch (err: any) {
|
| console.error('Email sign-up error:', err);
|
| let message = 'Could not create account.';
|
| if (err?.code === 'auth/verification-sent') {
|
| message = err.message;
|
| } else if (err?.code === 'auth/operation-not-allowed') {
|
| message =
|
| 'Email/Password registration is not enabled in Firebase Console. Go to Firebase Console > Authentication > Sign-in method > Enable "Email/Password", or click "Continue with Google".';
|
| } else if (err?.code === 'auth/email-already-in-use') {
|
| message = 'An account with this email already exists. Please sign in instead.';
|
| } else if (err?.code === 'auth/weak-password') {
|
| message = 'Password should be at least 6 characters.';
|
| } else if (err?.code === 'auth/invalid-email') {
|
| message = 'Please enter a valid email address.';
|
| } else if (err?.message) {
|
| message = err.message;
|
| }
|
| setAuthError(message);
|
| throw new Error(message);
|
| }
|
| };
|
|
|
| const handleSendVerificationEmail = async () => {
|
| setAuthError(null);
|
| if (!auth.currentUser) {
|
| const msg = 'You must be signed in to send a verification email.';
|
| setAuthError(msg);
|
| throw new Error(msg);
|
| }
|
| try {
|
| await sendUserEmailVerification(auth.currentUser);
|
| } catch (err: any) {
|
| console.error('Send verification email error:', err);
|
| let message = 'Failed to send verification email.';
|
| if (err?.code === 'auth/operation-not-allowed') {
|
| message =
|
| 'Email verification is not enabled in Firebase Console. Enable "Email/Password" provider in Firebase Console > Authentication > Sign-in method.';
|
| } else if (err?.code === 'auth/too-many-requests') {
|
| message = 'Too many requests. Please wait a few moments before trying to resend the verification email.';
|
| } else if (err?.message) {
|
| message = err.message;
|
| }
|
| setAuthError(message);
|
| throw new Error(message);
|
| }
|
| };
|
|
|
| const handleReloadUser = async () => {
|
| if (auth.currentUser) {
|
| await auth.currentUser.reload();
|
| const updatedUser = auth.currentUser;
|
| setUser({
|
| uid: updatedUser.uid,
|
| email: updatedUser.email,
|
| displayName: updatedUser.displayName || updatedUser.email?.split('@')[0] || 'Citizen',
|
| photoURL: updatedUser.photoURL,
|
| emailVerified: updatedUser.emailVerified,
|
| });
|
| }
|
| };
|
|
|
| const handleSignOut = async () => {
|
| setAuthError(null);
|
| try {
|
| await logOut();
|
| setUser(null);
|
| } catch (err: any) {
|
| console.error('Sign-out failed:', err);
|
| setUser(null);
|
| }
|
| };
|
|
|
| return (
|
| <AuthContext.Provider
|
| value={{
|
| user,
|
| loading,
|
| signIn: handleSignInGoogle,
|
| signInEmail: handleSignInEmail,
|
| signUpEmail: handleSignUpEmail,
|
| sendVerificationEmail: handleSendVerificationEmail,
|
| reloadUser: handleReloadUser,
|
| signOut: handleSignOut,
|
| authError,
|
| clearAuthError: () => setAuthError(null),
|
| }}
|
| >
|
| {children}
|
| </AuthContext.Provider>
|
| );
|
| };
|
|
|
| export const useAuth = () => useContext(AuthContext);
|
|
|
