Update main.py

main.py

@@ -144,33 +144,62 @@ def signup():
         if not email or not password:
             return jsonify({'error': 'Email and password are required'}), 400
 
-        # Create user in Firebase Authentication
+        logging.info(f"Attempting to create Firebase Auth user for email: {email}")
         user = auth.create_user(email=email, password=password)
+        logging.info(f"Firebase Auth user CREATED successfully: {user.uid} for email: {email}")
         
-        # Create corresponding user entry in Firebase Realtime Database
         user_ref = db.reference(f'users/{user.uid}')
-        user_data = {
+        user_data_to_set = {
             'email': email,
             'credits': 10,
             'is_admin': False,
             'created_at': datetime.utcnow().isoformat(),
-            'suspended': False # Ensure new accounts are not suspended by default
+            'suspended': False
         }
-        user_ref.set(user_data)
-        logging.info(f"New user {user.uid} signed up and DB entry created.")
+        
+        logging.info(f"Attempting to write user profile to DB for UID: {user.uid}. Data: {user_data_to_set}")
+        try:
+            user_ref.set(user_data_to_set)
+            logging.info(f"DB WRITE: user_ref.set() CALLED for UID: {user.uid}.")
+            
+            # VERIFICATION STEP: Immediately try to read the data back
+            time.sleep(0.5) # Small delay to allow for potential eventual consistency
+            retrieved_data = user_ref.get()
+            if retrieved_data and retrieved_data.get('email') == email:
+                logging.info(f"DB VERIFICATION SUCCESS: Data for UID {user.uid} read back successfully: {retrieved_data}")
+            else:
+                logging.error(f"DB VERIFICATION FAILED: Data for UID {user.uid} NOT found or mismatched after set. Retrieved: {retrieved_data}")
+                # This is a critical failure point if it happens
+                try:
+                    auth.delete_user(user.uid)
+                    logging.info(f"Auth user {user.uid} deleted due to DB verification failure.")
+                except Exception as auth_delete_err:
+                    logging.error(f"Failed to delete Auth user {user.uid} after DB verification failure: {auth_delete_err}")
+                return jsonify({'error': 'Failed to reliably save user profile to database after creation.'}), 500
+
+        except Exception as db_error:
+            logging.error(f"DATABASE WRITE EXCEPTION during user_ref.set() for new user UID {user.uid}: {db_error}")
+            logging.error(traceback.format_exc())
+            try:
+                auth.delete_user(user.uid)
+                logging.info(f"Cleaned up Firebase Auth user {user.uid} due to DB write exception.")
+            except Exception as auth_delete_err:
+                logging.error(f"Failed to cleanup Firebase Auth user {user.uid} after DB write exception: {auth_delete_err}")
+            return jsonify({'error': f'User created in Auth, but failed to save profile to database: {str(db_error)}'}), 500
 
         return jsonify({
             'success': True,
             'user': {
                 'uid': user.uid,
-                **user_data
+                **user_data_to_set 
             }
         }), 201
-    except Exception as e:
-        logging.error(f"Signup error: {e}")
-        # Firebase Auth errors can be specific, e.g., email-already-in-use
-        if 'email-already-in-use' in str(e):
-            return jsonify({'error': 'Email already in use.'}), 409 # Conflict
+    except auth.EmailAlreadyExistsError: # Specific Firebase Auth error
+        logging.warning(f"Signup attempt with existing email: {email}")
+        return jsonify({'error': 'Email already in use.'}), 409
+    except Exception as e: # General catch-all
+        logging.error(f"General signup error: {e}")
+        logging.error(traceback.format_exc())
         return jsonify({'error': str(e)}), 400
 
 @app.route('/api/user/profile', methods=['GET'])
@@ -220,35 +249,58 @@ def google_signin():
         decoded_token = auth.verify_id_token(token)
         uid = decoded_token['uid']
         email = decoded_token.get('email')
+        logging.info(f"Google Sign-In attempt for UID: {uid}, Email: {email}")
 
         user_ref = db.reference(f'users/{uid}')
-        user_data = user_ref.get()
+        user_data_from_db = user_ref.get() 
+        user_data_for_response = None
 
-        if not user_data:
-            # If user doesn't exist in DB, create a new entry
-            user_data = {
+        if not user_data_from_db:
+            logging.info(f"Google user {uid} (Email: {email}) not found in DB, creating new profile.")
+            new_user_data_to_set = {
                 'email': email,
                 'credits': 10,
                 'is_admin': False,
                 'created_at': datetime.utcnow().isoformat(),
                 'suspended': False
             }
-            user_ref.set(user_data)
-            logging.info(f"New Google user {uid} signed up and DB entry created.")
+            logging.info(f"Attempting to write Google user profile to DB for UID: {uid}. Data: {new_user_data_to_set}")
+            try:
+                user_ref.set(new_user_data_to_set) 
+                logging.info(f"DB WRITE: user_ref.set() CALLED for Google user UID: {uid}.")
+
+                # VERIFICATION STEP
+                time.sleep(0.5) 
+                retrieved_data = user_ref.get()
+                if retrieved_data and retrieved_data.get('email') == email:
+                    logging.info(f"DB VERIFICATION SUCCESS: Data for Google user UID {uid} read back successfully: {retrieved_data}")
+                    user_data_for_response = new_user_data_to_set 
+                else:
+                    logging.error(f"DB VERIFICATION FAILED: Data for Google user UID {uid} NOT found or mismatched after set. Retrieved: {retrieved_data}")
+                    # For Google Sign-In, the Auth user already exists, so we don't delete it.
+                    # The main issue is the DB profile creation.
+                    return jsonify({'error': 'Failed to reliably save Google user profile to database.'}), 500
+                    
+            except Exception as db_error:
+                logging.error(f"DATABASE WRITE EXCEPTION during user_ref.set() for new Google user UID {uid}: {db_error}")
+                logging.error(traceback.format_exc())
+                return jsonify({'error': f'User signed in with Google, but failed to save profile to database: {str(db_error)}'}), 500
         else:
-            logging.info(f"Existing Google user {uid} logged in.")
+            logging.info(f"Existing Google user {uid} logged in. DB data: {user_data_from_db}")
+            user_data_for_response = user_data_from_db
 
         return jsonify({
             'success': True,
             'user': {
                 'uid': uid,
-                **user_data
+                **user_data_for_response 
             }
         }), 200
 
-    except Exception as e:
+    except Exception as e: # General catch-all for token verification or other issues
         logging.error(f"Google sign-in error: {e}")
-        return jsonify({'error': str(e)}), 400 
+        logging.error(traceback.format_exc())
+        return jsonify({'error': str(e)}), 400
 
 @app.route('/api/user/request-credits', methods=['POST'])
 @credit_required(cost=0)