Only log to admin media_clicks if user_id is provided; regular MongoDB logging always happens

api/main.py

@@ -158,8 +158,12 @@ def _coerce_category_id(category_id: Optional[str]) -> ObjectId:
 
 
 def log_media_click(user_id: Optional[str], category_id: Optional[str]) -> None:
+    """Log to admin media_clicks collection only if user_id is provided."""
     if admin_media_clicks is None:
         return
+    # Only log if user_id is provided (not None/empty)
+    if not user_id or not user_id.strip():
+        return
     try:
         user_obj = _coerce_object_id(user_id)
         category_obj = _coerce_category_id(category_id)
@@ -442,27 +446,56 @@ def inpaint(req: InpaintRequest, _: None = Depends(bearer_auth)) -> Dict[str, st
 @app.post("/inpaint-url")
 def inpaint_url(req: InpaintRequest, request: Request, _: None = Depends(bearer_auth)) -> Dict[str, str]:
     """Same as /inpaint but returns a JSON with a public download URL instead of image bytes."""
-    if req.image_id not in file_store or file_store[req.image_id]["type"] != "image":
-        raise HTTPException(status_code=404, detail="image_id not found")
-    if req.mask_id not in file_store or file_store[req.mask_id]["type"] != "mask":
-        raise HTTPException(status_code=404, detail="mask_id not found")
+    start_time = time.time()
+    status = "success"
+    error_msg = None
+    result_name = None
 
-    img_rgba = _load_rgba_image(file_store[req.image_id]["path"])
-    mask_img = Image.open(file_store[req.mask_id]["path"])  # may be RGB/gray/RGBA
-    mask_rgba = _load_rgba_mask_from_image(mask_img)
+    try:
+        if req.image_id not in file_store or file_store[req.image_id]["type"] != "image":
+            raise HTTPException(status_code=404, detail="image_id not found")
+        if req.mask_id not in file_store or file_store[req.mask_id]["type"] != "mask":
+            raise HTTPException(status_code=404, detail="mask_id not found")
 
-    if req.passthrough:
-        result = np.array(img_rgba.convert("RGB"))
-    else:
-        result = process_inpaint(np.array(img_rgba), mask_rgba, invert_mask=req.invert_mask)
-    result_name = f"output_{uuid.uuid4().hex}.png"
-    result_path = os.path.join(OUTPUT_DIR, result_name)
-    Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
+        img_rgba = _load_rgba_image(file_store[req.image_id]["path"])
+        mask_img = Image.open(file_store[req.mask_id]["path"])  # may be RGB/gray/RGBA
+        mask_rgba = _load_rgba_mask_from_image(mask_img)
 
-    url = str(request.url_for("download_file", filename=result_name))
-    logs.append({"result": result_name, "url": url, "timestamp": datetime.utcnow().isoformat()})
-    log_media_click(req.user_id, req.category_id)
-    return {"result": result_name, "url": url}
+        if req.passthrough:
+            result = np.array(img_rgba.convert("RGB"))
+        else:
+            result = process_inpaint(np.array(img_rgba), mask_rgba, invert_mask=req.invert_mask)
+        result_name = f"output_{uuid.uuid4().hex}.png"
+        result_path = os.path.join(OUTPUT_DIR, result_name)
+        Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
+
+        url = str(request.url_for("download_file", filename=result_name))
+        logs.append({"result": result_name, "url": url, "timestamp": datetime.utcnow().isoformat()})
+        log_media_click(req.user_id, req.category_id)
+        return {"result": result_name, "url": url}
+    except Exception as e:
+        status = "fail"
+        error_msg = str(e)
+        raise
+    finally:
+        # Always log to regular MongoDB (mandatory)
+        end_time = time.time()
+        response_time_ms = (end_time - start_time) * 1000
+        log_doc = {
+            "input_image_id": req.image_id,
+            "input_mask_id": req.mask_id,
+            "output_id": result_name,
+            "status": status,
+            "timestamp": datetime.utcnow(),
+            "ts": int(time.time()),
+            "response_time_ms": response_time_ms,
+        }
+        if error_msg:
+            log_doc["error"] = error_msg
+        try:
+            mongo_logs.insert_one(log_doc)
+        except Exception as mongo_err:
+            log.error("Mongo log insert failed: %s", mongo_err)
 
 
 @app.post("/inpaint-multipart")
@@ -477,13 +510,115 @@ def inpaint_multipart(
     category_id: Optional[str] = Form(None),
     _: None = Depends(bearer_auth),
 ) -> Dict[str, str]:
-    # Load in-memory
-    img = Image.open(image.file).convert("RGBA")
-    m = Image.open(mask.file).convert("RGBA")
+    start_time = time.time()
+    status = "success"
+    error_msg = None
+    result_name = None
+    
+    try:
+        # Load in-memory
+        img = Image.open(image.file).convert("RGBA")
+        m = Image.open(mask.file).convert("RGBA")
+
+        if passthrough:
+            # Just echo the input image, ignore mask
+            result = np.array(img.convert("RGB"))
+            result_name = f"output_{uuid.uuid4().hex}.png"
+            result_path = os.path.join(OUTPUT_DIR, result_name)
+            Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
+
+            url: Optional[str] = None
+            try:
+                if request is not None:
+                    url = str(request.url_for("download_file", filename=result_name))
+            except Exception:
+                url = None
+
+            entry: Dict[str, str] = {"result": result_name, "timestamp": datetime.utcnow().isoformat()}
+            if url:
+                entry["url"] = url
+            logs.append(entry)
+            resp: Dict[str, str] = {"result": result_name}
+            if url:
+                resp["url"] = url
+            log_media_click(user_id, category_id)
+            return resp
+
+        if mask_is_painted:
+            # Auto-detect pink/magenta paint and convert to black/white mask
+            # White pixels = areas to remove, Black pixels = areas to keep
+            log.info("Auto-detecting pink/magenta paint from uploaded image...")
+            
+            m_rgb = cv2.cvtColor(np.array(m), cv2.COLOR_RGBA2RGB)
+            
+            # Detect pink/magenta using fixed RGB bounds (same as /remove-pink)
+            lower = np.array([150, 0, 100], dtype=np.uint8)
+            upper = np.array([255, 120, 255], dtype=np.uint8)
+            magenta_detected = (
+                (m_rgb[:, :, 0] >= lower[0]) & (m_rgb[:, :, 0] <= upper[0]) &
+                (m_rgb[:, :, 1] >= lower[1]) & (m_rgb[:, :, 1] <= upper[1]) &
+                (m_rgb[:, :, 2] >= lower[2]) & (m_rgb[:, :, 2] <= upper[2])
+            ).astype(np.uint8) * 255
+            
+            # Method 2: Also check if original image was provided to find differences
+            if img is not None:
+                img_rgb = cv2.cvtColor(np.array(img), cv2.COLOR_RGBA2RGB)
+                if img_rgb.shape == m_rgb.shape:
+                    diff = cv2.absdiff(img_rgb, m_rgb)
+                    gray_diff = cv2.cvtColor(diff, cv2.COLOR_RGB2GRAY)
+                    # Any significant difference (>50) could be paint
+                    diff_mask = (gray_diff > 50).astype(np.uint8) * 255
+                    # Combine with magenta detection
+                    binmask = cv2.bitwise_or(magenta_detected, diff_mask)
+                else:
+                    binmask = magenta_detected
+            else:
+                # No original image provided, use magenta detection only
+                binmask = magenta_detected
+            
+            # Clean up the mask: remove noise and fill small holes
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+            # Close small gaps in the mask
+            binmask = cv2.morphologyEx(binmask, cv2.MORPH_CLOSE, kernel, iterations=2)
+            # Remove small noise
+            binmask = cv2.morphologyEx(binmask, cv2.MORPH_OPEN, kernel, iterations=1)
+            
+            nonzero = int((binmask > 0).sum())
+            log.info("Pink/magenta paint detected: %d pixels marked for removal (white)", nonzero)
+            
+            # If very few pixels detected, assume the user may already be providing a BW mask
+            # and proceed without forcing strict detection
+            
+            if nonzero < 50:
+                log.error("CRITICAL: Could not detect pink/magenta paint! Returning original image.")
+                result = np.array(img.convert("RGB")) if img else np.array(m.convert("RGB"))
+                result_name = f"output_{uuid.uuid4().hex}.png"
+                result_path = os.path.join(OUTPUT_DIR, result_name)
+                Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
+                return {"result": result_name, "error": "pink/magenta paint detection failed - very few pixels detected"}
+            
+            # Create binary mask: Pink pixels → white (255), Everything else → black (0)
+            # Encode in RGBA format for process_inpaint
+            # process_inpaint does: mask = 255 - mask[:,:,3]
+            # So: alpha=0 (transparent/pink) → becomes 255 (white/remove)
+            #     alpha=255 (opaque/keep) → becomes 0 (black/keep)
+            mask_rgba = np.zeros((binmask.shape[0], binmask.shape[1], 4), dtype=np.uint8)
+            mask_rgba[:, :, 0] = binmask  # R: white where pink (for visualization)
+            mask_rgba[:, :, 1] = binmask  # G: white where pink
+            mask_rgba[:, :, 2] = binmask  # B: white where pink
+            # Alpha: invert so pink areas get alpha=0 → will become white after 255-alpha
+            mask_rgba[:, :, 3] = 255 - binmask
+            
+            log.info("Successfully created binary mask: %d pink pixels → white (255), %d pixels → black (0)",
+                     nonzero, binmask.shape[0] * binmask.shape[1] - nonzero)
+        else:
+            mask_rgba = _load_rgba_mask_from_image(m)
 
-    if passthrough:
-        # Just echo the input image, ignore mask
-        result = np.array(img.convert("RGB"))
+        # When mask_is_painted=true, we encode pink as alpha=0, so process_inpaint's default invert_mask=True works correctly
+        actual_invert = invert_mask  # Use default True for painted masks
+        log.info("Using invert_mask=%s (mask_is_painted=%s)", actual_invert, mask_is_painted)
+        
+        result = process_inpaint(np.array(img), mask_rgba, invert_mask=actual_invert)
         result_name = f"output_{uuid.uuid4().hex}.png"
         result_path = os.path.join(OUTPUT_DIR, result_name)
         Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
@@ -504,216 +639,170 @@ def inpaint_multipart(
             resp["url"] = url
         log_media_click(user_id, category_id)
         return resp
+    except Exception as e:
+        status = "fail"
+        error_msg = str(e)
+        raise
+    finally:
+        # Always log to regular MongoDB (mandatory)
+        end_time = time.time()
+        response_time_ms = (end_time - start_time) * 1000
+        log_doc = {
+            "endpoint": "inpaint-multipart",
+            "output_id": result_name,
+            "status": status,
+            "timestamp": datetime.utcnow(),
+            "ts": int(time.time()),
+            "response_time_ms": response_time_ms,
+        }
+        if error_msg:
+            log_doc["error"] = error_msg
+        try:
+            mongo_logs.insert_one(log_doc)
+        except Exception as mongo_err:
+            log.error("Mongo log insert failed: %s", mongo_err)
 
-    if mask_is_painted:
-        # Auto-detect pink/magenta paint and convert to black/white mask
-        # White pixels = areas to remove, Black pixels = areas to keep
-        log.info("Auto-detecting pink/magenta paint from uploaded image...")
+
+@app.post("/remove-pink")
+def remove_pink_segments(
+    image: UploadFile = File(...),
+    request: Request = None,
+    user_id: Optional[str] = Form(None),
+    category_id: Optional[str] = Form(None),
+    _: None = Depends(bearer_auth),
+) -> Dict[str, str]:
+    """
+    Simple endpoint: upload an image with pink/magenta segments to remove.
+    - Pink/Magenta segments → automatically removed (white in mask)
+    - Everything else → automatically kept (black in mask)
+    Just paint pink/magenta on areas you want to remove, upload the image, and it works!
+    """
+    start_time = time.time()
+    status = "success"
+    error_msg = None
+    result_name = None
+    
+    try:
+        log.info(f"Simple remove-pink: processing image {image.filename}")
         
-        m_rgb = cv2.cvtColor(np.array(m), cv2.COLOR_RGBA2RGB)
+        # Load the image (with pink paint on it)
+        img = Image.open(image.file).convert("RGBA")
+        img_rgb = cv2.cvtColor(np.array(img), cv2.COLOR_RGBA2RGB)
         
-        # Detect pink/magenta using fixed RGB bounds (same as /remove-pink)
+        # Auto-detect pink/magenta segments to remove
+        # Pink/Magenta → white in mask (remove)
+        # Everything else (natural image colors, including dark areas) → black in mask (keep)
+        
+        # Detect pink/magenta using fixed RGB bounds per requested logic
         lower = np.array([150, 0, 100], dtype=np.uint8)
         upper = np.array([255, 120, 255], dtype=np.uint8)
-        magenta_detected = (
-            (m_rgb[:, :, 0] >= lower[0]) & (m_rgb[:, :, 0] <= upper[0]) &
-            (m_rgb[:, :, 1] >= lower[1]) & (m_rgb[:, :, 1] <= upper[1]) &
-            (m_rgb[:, :, 2] >= lower[2]) & (m_rgb[:, :, 2] <= upper[2])
+        binmask = (
+            (img_rgb[:, :, 0] >= lower[0]) & (img_rgb[:, :, 0] <= upper[0]) &
+            (img_rgb[:, :, 1] >= lower[1]) & (img_rgb[:, :, 1] <= upper[1]) &
+            (img_rgb[:, :, 2] >= lower[2]) & (img_rgb[:, :, 2] <= upper[2])
         ).astype(np.uint8) * 255
         
-        # Method 2: Also check if original image was provided to find differences
-        if img is not None:
-            img_rgb = cv2.cvtColor(np.array(img), cv2.COLOR_RGBA2RGB)
-            if img_rgb.shape == m_rgb.shape:
-                diff = cv2.absdiff(img_rgb, m_rgb)
-                gray_diff = cv2.cvtColor(diff, cv2.COLOR_RGB2GRAY)
-                # Any significant difference (>50) could be paint
-                diff_mask = (gray_diff > 50).astype(np.uint8) * 255
-                # Combine with magenta detection
-                binmask = cv2.bitwise_or(magenta_detected, diff_mask)
-            else:
-                binmask = magenta_detected
-        else:
-            # No original image provided, use magenta detection only
-            binmask = magenta_detected
-        
-        # Clean up the mask: remove noise and fill small holes
+        # Clean up the pink mask
         kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-        # Close small gaps in the mask
         binmask = cv2.morphologyEx(binmask, cv2.MORPH_CLOSE, kernel, iterations=2)
-        # Remove small noise
         binmask = cv2.morphologyEx(binmask, cv2.MORPH_OPEN, kernel, iterations=1)
         
         nonzero = int((binmask > 0).sum())
-        log.info("Pink/magenta paint detected: %d pixels marked for removal (white)", nonzero)
+        total_pixels = binmask.shape[0] * binmask.shape[1]
+        log.info(f"Detected {nonzero} pink pixels ({100*nonzero/total_pixels:.2f}% of image) to remove")
         
-        # If very few pixels detected, assume the user may already be providing a BW mask
-        # and proceed without forcing strict detection
+        # Debug: log bounds used
+        log.info("Pink detection bounds used: lower=[150,0,100], upper=[255,120,255]")
         
         if nonzero < 50:
-            log.error("CRITICAL: Could not detect pink/magenta paint! Returning original image.")
-            result = np.array(img.convert("RGB")) if img else np.array(m.convert("RGB"))
+            log.error("No pink segments detected! Returning original image.")
+            result = np.array(img.convert("RGB"))
             result_name = f"output_{uuid.uuid4().hex}.png"
             result_path = os.path.join(OUTPUT_DIR, result_name)
             Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
-            return {"result": result_name, "error": "pink/magenta paint detection failed - very few pixels detected"}
+            return {
+                "result": result_name,
+                "error": "No pink/magenta segments detected. Please paint areas to remove with magenta/pink color (RGB 255,0,255)."
+            }
         
         # Create binary mask: Pink pixels → white (255), Everything else → black (0)
-        # Encode in RGBA format for process_inpaint
+        # Encode in RGBA format that process_inpaint expects
         # process_inpaint does: mask = 255 - mask[:,:,3]
         # So: alpha=0 (transparent/pink) → becomes 255 (white/remove)
         #     alpha=255 (opaque/keep) → becomes 0 (black/keep)
         mask_rgba = np.zeros((binmask.shape[0], binmask.shape[1], 4), dtype=np.uint8)
-        mask_rgba[:, :, 0] = binmask  # R: white where pink (for visualization)
-        mask_rgba[:, :, 1] = binmask  # G: white where pink
+        # RGB channels don't matter for process_inpaint, but set them to white where pink for visualization
+        mask_rgba[:, :, 0] = binmask  # R: white where pink
+        mask_rgba[:, :, 1] = binmask  # G: white where pink  
         mask_rgba[:, :, 2] = binmask  # B: white where pink
-        # Alpha: invert so pink areas get alpha=0 → will become white after 255-alpha
-        mask_rgba[:, :, 3] = 255 - binmask
+        # Alpha: 0 (transparent) where pink → will become white after 255-alpha
+        #        255 (opaque) everywhere else → will become black after 255-alpha
+        mask_rgba[:, :, 3] = 255 - binmask  # Invert: pink areas get alpha=0, rest get alpha=255
         
-        log.info("Successfully created binary mask: %d pink pixels → white (255), %d pixels → black (0)",
-                 nonzero, binmask.shape[0] * binmask.shape[1] - nonzero)
-    else:
-        mask_rgba = _load_rgba_mask_from_image(m)
-
-    # When mask_is_painted=true, we encode pink as alpha=0, so process_inpaint's default invert_mask=True works correctly
-    actual_invert = invert_mask  # Use default True for painted masks
-    log.info("Using invert_mask=%s (mask_is_painted=%s)", actual_invert, mask_is_painted)
-    
-    result = process_inpaint(np.array(img), mask_rgba, invert_mask=actual_invert)
-    result_name = f"output_{uuid.uuid4().hex}.png"
-    result_path = os.path.join(OUTPUT_DIR, result_name)
-    Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
-
-    url: Optional[str] = None
-    try:
-        if request is not None:
-            url = str(request.url_for("download_file", filename=result_name))
-    except Exception:
-        url = None
-
-    entry: Dict[str, str] = {"result": result_name, "timestamp": datetime.utcnow().isoformat()}
-    if url:
-        entry["url"] = url
-    logs.append(entry)
-    resp: Dict[str, str] = {"result": result_name}
-    if url:
-        resp["url"] = url
-    log_media_click(user_id, category_id)
-    return resp
-
-
-@app.post("/remove-pink")
-def remove_pink_segments(
-    image: UploadFile = File(...),
-    request: Request = None,
-    user_id: Optional[str] = Form(None),
-    category_id: Optional[str] = Form(None),
-    _: None = Depends(bearer_auth),
-) -> Dict[str, str]:
-    """
-    Simple endpoint: upload an image with pink/magenta segments to remove.
-    - Pink/Magenta segments → automatically removed (white in mask)
-    - Everything else → automatically kept (black in mask)
-    Just paint pink/magenta on areas you want to remove, upload the image, and it works!
-    """
-    log.info(f"Simple remove-pink: processing image {image.filename}")
-    
-    # Load the image (with pink paint on it)
-    img = Image.open(image.file).convert("RGBA")
-    img_rgb = cv2.cvtColor(np.array(img), cv2.COLOR_RGBA2RGB)
-    
-    # Auto-detect pink/magenta segments to remove
-    # Pink/Magenta → white in mask (remove)
-    # Everything else (natural image colors, including dark areas) → black in mask (keep)
-    
-    # Detect pink/magenta using fixed RGB bounds per requested logic
-    lower = np.array([150, 0, 100], dtype=np.uint8)
-    upper = np.array([255, 120, 255], dtype=np.uint8)
-    binmask = (
-        (img_rgb[:, :, 0] >= lower[0]) & (img_rgb[:, :, 0] <= upper[0]) &
-        (img_rgb[:, :, 1] >= lower[1]) & (img_rgb[:, :, 1] <= upper[1]) &
-        (img_rgb[:, :, 2] >= lower[2]) & (img_rgb[:, :, 2] <= upper[2])
-    ).astype(np.uint8) * 255
-    
-    # Clean up the pink mask
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    binmask = cv2.morphologyEx(binmask, cv2.MORPH_CLOSE, kernel, iterations=2)
-    binmask = cv2.morphologyEx(binmask, cv2.MORPH_OPEN, kernel, iterations=1)
-    
-    nonzero = int((binmask > 0).sum())
-    total_pixels = binmask.shape[0] * binmask.shape[1]
-    log.info(f"Detected {nonzero} pink pixels ({100*nonzero/total_pixels:.2f}% of image) to remove")
-    
-    # Debug: log bounds used
-    log.info("Pink detection bounds used: lower=[150,0,100], upper=[255,120,255]")
-    
-    if nonzero < 50:
-        log.error("No pink segments detected! Returning original image.")
-        result = np.array(img.convert("RGB"))
+        # Verify mask encoding
+        alpha_zero_count = int((mask_rgba[:,:,3] == 0).sum())
+        alpha_255_count = int((mask_rgba[:,:,3] == 255).sum())
+        total_pixels = binmask.shape[0] * binmask.shape[1]
+        log.info(f"Mask encoding: {alpha_zero_count} pixels with alpha=0 (pink), {alpha_255_count} pixels with alpha=255 (keep)")
+        log.info(f"After 255-alpha conversion: {alpha_zero_count} will become white (255/remove), {alpha_255_count} will become black (0/keep)")
+        
+        # IMPORTANT: We need to use the ORIGINAL image WITHOUT pink paint for inpainting!
+        # Remove pink from the original image before processing
+        # Create a clean version: where pink was detected, keep original image colors
+        img_clean = np.array(img.convert("RGBA"))
+        # Where pink is detected, we want to inpaint, so we can leave it (or blend it out)
+        # Actually, the model will inpaint over those areas, so we can pass the original
+        # But for better results, we might want to remove the pink overlay first
+        
+        # Process with invert_mask=True (default) because process_inpaint expects alpha=0 for removal
+        log.info(f"Starting inpainting process...")
+        result = process_inpaint(img_clean, mask_rgba, invert_mask=True)
+        log.info(f"Inpainting complete, result shape: {result.shape}")
         result_name = f"output_{uuid.uuid4().hex}.png"
         result_path = os.path.join(OUTPUT_DIR, result_name)
         Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
-        return {
+        
+        url: Optional[str] = None
+        try:
+            if request is not None:
+                url = str(request.url_for("download_file", filename=result_name))
+        except Exception:
+            url = None
+        
+        logs.append({
             "result": result_name,
-            "error": "No pink/magenta segments detected. Please paint areas to remove with magenta/pink color (RGB 255,0,255)."
+            "filename": image.filename,
+            "pink_pixels": nonzero,
+            "timestamp": datetime.utcnow().isoformat()
+        })
+        
+        resp: Dict[str, str] = {"result": result_name, "pink_segments_detected": str(nonzero)}
+        if url:
+            resp["url"] = url
+        log_media_click(user_id, category_id)
+        return resp
+    except Exception as e:
+        status = "fail"
+        error_msg = str(e)
+        raise
+    finally:
+        # Always log to regular MongoDB (mandatory)
+        end_time = time.time()
+        response_time_ms = (end_time - start_time) * 1000
+        log_doc = {
+            "endpoint": "remove-pink",
+            "output_id": result_name,
+            "status": status,
+            "timestamp": datetime.utcnow(),
+            "ts": int(time.time()),
+            "response_time_ms": response_time_ms,
         }
-    
-    # Create binary mask: Pink pixels → white (255), Everything else → black (0)
-    # Encode in RGBA format that process_inpaint expects
-    # process_inpaint does: mask = 255 - mask[:,:,3]
-    # So: alpha=0 (transparent/pink) → becomes 255 (white/remove)
-    #     alpha=255 (opaque/keep) → becomes 0 (black/keep)
-    mask_rgba = np.zeros((binmask.shape[0], binmask.shape[1], 4), dtype=np.uint8)
-    # RGB channels don't matter for process_inpaint, but set them to white where pink for visualization
-    mask_rgba[:, :, 0] = binmask  # R: white where pink
-    mask_rgba[:, :, 1] = binmask  # G: white where pink  
-    mask_rgba[:, :, 2] = binmask  # B: white where pink
-    # Alpha: 0 (transparent) where pink → will become white after 255-alpha
-    #        255 (opaque) everywhere else → will become black after 255-alpha
-    mask_rgba[:, :, 3] = 255 - binmask  # Invert: pink areas get alpha=0, rest get alpha=255
-    
-    # Verify mask encoding
-    alpha_zero_count = int((mask_rgba[:,:,3] == 0).sum())
-    alpha_255_count = int((mask_rgba[:,:,3] == 255).sum())
-    total_pixels = binmask.shape[0] * binmask.shape[1]
-    log.info(f"Mask encoding: {alpha_zero_count} pixels with alpha=0 (pink), {alpha_255_count} pixels with alpha=255 (keep)")
-    log.info(f"After 255-alpha conversion: {alpha_zero_count} will become white (255/remove), {alpha_255_count} will become black (0/keep)")
-    
-    # IMPORTANT: We need to use the ORIGINAL image WITHOUT pink paint for inpainting!
-    # Remove pink from the original image before processing
-    # Create a clean version: where pink was detected, keep original image colors
-    img_clean = np.array(img.convert("RGBA"))
-    # Where pink is detected, we want to inpaint, so we can leave it (or blend it out)
-    # Actually, the model will inpaint over those areas, so we can pass the original
-    # But for better results, we might want to remove the pink overlay first
-    
-    # Process with invert_mask=True (default) because process_inpaint expects alpha=0 for removal
-    log.info(f"Starting inpainting process...")
-    result = process_inpaint(img_clean, mask_rgba, invert_mask=True)
-    log.info(f"Inpainting complete, result shape: {result.shape}")
-    result_name = f"output_{uuid.uuid4().hex}.png"
-    result_path = os.path.join(OUTPUT_DIR, result_name)
-    Image.fromarray(result).save(result_path, "PNG", optimize=False, compress_level=1)
-    
-    url: Optional[str] = None
-    try:
-        if request is not None:
-            url = str(request.url_for("download_file", filename=result_name))
-    except Exception:
-        url = None
-    
-    logs.append({
-        "result": result_name,
-        "filename": image.filename,
-        "pink_pixels": nonzero,
-        "timestamp": datetime.utcnow().isoformat()
-    })
-    
-    resp: Dict[str, str] = {"result": result_name, "pink_segments_detected": str(nonzero)}
-    if url:
-        resp["url"] = url
-    log_media_click(user_id, category_id)
-    return resp
+        if error_msg:
+            log_doc["error"] = error_msg
+        try:
+            mongo_logs.insert_one(log_doc)
+        except Exception as mongo_err:
+            log.error("Mongo log insert failed: %s", mongo_err)
 
 
 @app.get("/download/{filename}")