Update api/main.py

api/main.py

@@ -2,6 +2,7 @@ import os
 import uuid
 import shutil
 import re
+import threading
 from datetime import datetime, timedelta, date
 from io import BytesIO
 from typing import Dict, List, Optional,Any
@@ -21,6 +22,7 @@ from pydantic import BaseModel
 from PIL import Image, UnidentifiedImageError
 import cv2
 import logging
+import boto3
 from gridfs import GridFS
 from gridfs.errors import NoFile
 
@@ -53,6 +55,18 @@ OUTPUT_DIR = os.path.join(BASE_DIR, "outputs")
 os.makedirs(UPLOAD_DIR, exist_ok=True)
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
+SPACES_BUCKET = os.environ.get("DO_SPACES_BUCKET", "milestone")
+SPACES_REGION = os.environ.get("DO_SPACES_REGION", "blr1")
+SPACES_ENDPOINT = os.environ.get(
+    "DO_SPACES_ENDPOINT",
+    f"https://{SPACES_REGION}.digitaloceanspaces.com",
+)
+SPACES_KEY = os.environ.get("DO_SPACES_KEY")
+SPACES_SECRET = os.environ.get("DO_SPACES_SECRET")
+SPACES_ROOT_PREFIX = os.environ.get("DO_SPACES_ROOT_PREFIX", "valentine/objectremover").strip("/")
+SPACES_SOURCE_PREFIX = f"{SPACES_ROOT_PREFIX}/source"
+SPACES_RESULTS_PREFIX = f"{SPACES_ROOT_PREFIX}/results"
+
 # Optional Bearer token: set env API_TOKEN to require auth; if not set, endpoints are open
 ENV_TOKEN = os.environ.get("API_TOKEN")
 
@@ -112,6 +126,10 @@ API_LOGS_MONGO_URI = os.environ.get("API_LOGS_MONGODB_URL")
 api_logs_client = None
 api_logs_db = None
 api_logs_collection = None
+spaces_client = None
+spaces_enabled = False
+spaces_counter_lock = threading.Lock()
+spaces_pair_counter: Optional[int] = None
 
 if API_LOGS_MONGO_URI:
     try:
@@ -124,6 +142,29 @@ if API_LOGS_MONGO_URI:
         api_logs_collection = None
 else:
     log.warning("API_LOGS_MONGODB_URL not set. API logging disabled.")
+
+if SPACES_KEY and SPACES_SECRET:
+    try:
+        spaces_client = boto3.client(
+            "s3",
+            region_name=SPACES_REGION,
+            endpoint_url=SPACES_ENDPOINT,
+            aws_access_key_id=SPACES_KEY,
+            aws_secret_access_key=SPACES_SECRET,
+        )
+        spaces_enabled = True
+        log.info(
+            "DigitalOcean Spaces initialized: bucket=%s source_prefix=%s results_prefix=%s",
+            SPACES_BUCKET,
+            SPACES_SOURCE_PREFIX,
+            SPACES_RESULTS_PREFIX,
+        )
+    except Exception as err:
+        log.error("Failed to initialize DigitalOcean Spaces client: %s", err, exc_info=True)
+        spaces_client = None
+        spaces_enabled = False
+else:
+    log.info("DigitalOcean Spaces not configured; source/result mirroring disabled")
     
 ADMIN_MONGO_URI = os.environ.get("MONGODB_ADMIN")
 DEFAULT_CATEGORY_ID = "69368f722e46bd68ae188984"
@@ -386,6 +427,110 @@ def _load_rgba_image_from_gridfs(file_id: str, expected_type: str) -> Image.Imag
     return img.convert("RGBA")
 
 
+def _pil_to_jpeg_bytes(img: Image.Image, quality: int = 95) -> bytes:
+    buf = BytesIO()
+    rgb_img = img.convert("RGB")
+    rgb_img.save(buf, format="JPEG", quality=quality)
+    return buf.getvalue()
+
+
+def _pil_to_png_bytes(img: Image.Image) -> bytes:
+    buf = BytesIO()
+    img.save(buf, format="PNG", optimize=False, compress_level=1)
+    return buf.getvalue()
+
+
+def _extract_pair_number_from_key(key: str, prefix: str, file_label: str, ext: str) -> Optional[int]:
+    normalized_prefix = prefix.strip("/")
+    pattern = rf"^{re.escape(normalized_prefix)}/{file_label}_(\d+)\.{re.escape(ext)}$"
+    match = re.match(pattern, key)
+    if not match:
+        return None
+    return int(match.group(1))
+
+
+def _fetch_spaces_max_pair_number() -> int:
+    if not spaces_enabled or spaces_client is None:
+        return 0
+
+    max_number = 0
+    for prefix, label, ext in (
+        (SPACES_SOURCE_PREFIX, "source", "jpg"),
+        (SPACES_RESULTS_PREFIX, "result", "png"),
+    ):
+        continuation_token = None
+        while True:
+            kwargs = {
+                "Bucket": SPACES_BUCKET,
+                "Prefix": f"{prefix}/",
+                "MaxKeys": 1000,
+            }
+            if continuation_token:
+                kwargs["ContinuationToken"] = continuation_token
+            response = spaces_client.list_objects_v2(**kwargs)
+            for item in response.get("Contents", []):
+                key = item.get("Key", "")
+                pair_number = _extract_pair_number_from_key(key, prefix, label, ext)
+                if pair_number is not None:
+                    max_number = max(max_number, pair_number)
+            if not response.get("IsTruncated"):
+                break
+            continuation_token = response.get("NextContinuationToken")
+    return max_number
+
+
+def _next_spaces_pair_number() -> int:
+    global spaces_pair_counter
+
+    if not spaces_enabled or spaces_client is None:
+        raise RuntimeError("DigitalOcean Spaces is not configured")
+
+    with spaces_counter_lock:
+        if spaces_pair_counter is None:
+            spaces_pair_counter = _fetch_spaces_max_pair_number()
+        spaces_pair_counter += 1
+        return spaces_pair_counter
+
+
+def _upload_bytes_to_spaces(data: bytes, key: str, content_type: str) -> None:
+    if not spaces_enabled or spaces_client is None:
+        return
+    spaces_client.put_object(
+        Bucket=SPACES_BUCKET,
+        Key=key,
+        Body=data,
+        ContentType=content_type,
+    )
+
+
+def _mirror_source_result_to_spaces(
+    source_image: Image.Image,
+    result_image: Image.Image,
+) -> Optional[Dict[str, str]]:
+    if not spaces_enabled or spaces_client is None:
+        return None
+
+    pair_number = _next_spaces_pair_number()
+    source_key = f"{SPACES_SOURCE_PREFIX}/source_{pair_number}.jpg"
+    result_key = f"{SPACES_RESULTS_PREFIX}/result_{pair_number}.png"
+
+    source_bytes = _pil_to_jpeg_bytes(source_image)
+    result_bytes = _pil_to_png_bytes(result_image)
+
+    _upload_bytes_to_spaces(source_bytes, source_key, "image/jpeg")
+    _upload_bytes_to_spaces(result_bytes, result_key, "image/png")
+    log.info(
+        "Mirrored source/result to Spaces: source_key=%s result_key=%s",
+        source_key,
+        result_key,
+    )
+    return {
+        "source_key": source_key,
+        "result_key": result_key,
+        "pair_number": str(pair_number),
+    }
+
+
 def _build_ai_edit_daily_count(
     existing: Optional[List[Dict[str, object]]],
     today: date,
@@ -820,6 +965,7 @@ def inpaint(req: InpaintRequest, request: Request, _: None = Depends(bearer_auth
     error_msg = None
     output_name = None
     compressed_url = None
+    spaces_info = None
 
     try:
         # Handle appname="collage-maker": get category_id from collage-maker if not provided
@@ -846,9 +992,12 @@ def inpaint(req: InpaintRequest, request: Request, _: None = Depends(bearer_auth
         output_name = f"output_{uuid.uuid4().hex}.png"
         output_path = os.path.join(OUTPUT_DIR, output_name)
 
-        Image.fromarray(result).save(
-            output_path, "PNG", optimize=False, compress_level=1
-        )
+        result_image = Image.fromarray(result)
+        result_image.save(output_path, "PNG", optimize=False, compress_level=1)
+        try:
+            spaces_info = _mirror_source_result_to_spaces(img_rgba, result_image)
+        except Exception as spaces_err:
+            log.error("Failed to mirror /inpaint images to DigitalOcean Spaces: %s", spaces_err, exc_info=True)
 
         # Create compressed version
         compressed_name = f"compressed_{output_name.replace('.png', '.jpg')}"
@@ -869,6 +1018,9 @@ def inpaint(req: InpaintRequest, request: Request, _: None = Depends(bearer_auth
         response = {"result": output_name}
         if compressed_url:
             response["Compressed_Image_URL"] = compressed_url
+        if spaces_info:
+            response["source_space_key"] = spaces_info["source_key"]
+            response["result_space_key"] = spaces_info["result_key"]
         return response
 
     except Exception as e:
@@ -904,6 +1056,9 @@ def inpaint(req: InpaintRequest, request: Request, _: None = Depends(bearer_auth
 
         if error_msg:
             log_doc["error"] = error_msg
+        if spaces_info:
+            log_doc["source_space_key"] = spaces_info["source_key"]
+            log_doc["result_space_key"] = spaces_info["result_key"]
 
         # if mongo_logs is not None:
         #     try:
@@ -967,6 +1122,7 @@ def inpaint_url(req: InpaintRequest, request: Request, _: None = Depends(bearer_
     status = "success"
     error_msg = None
     result_name = None
+    spaces_info = None
 
     try:
         # Handle appname="collage-maker": get category_id from collage-maker if not provided
@@ -991,12 +1147,21 @@ def inpaint_url(req: InpaintRequest, request: Request, _: None = Depends(bearer_
             )
         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)
+        result_image = Image.fromarray(result)
+        result_image.save(result_path, "PNG", optimize=False, compress_level=1)
+        try:
+            spaces_info = _mirror_source_result_to_spaces(img_rgba, result_image)
+        except Exception as spaces_err:
+            log.error("Failed to mirror /inpaint-url images to DigitalOcean Spaces: %s", spaces_err, exc_info=True)
 
         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, category_id, req.appname)
-        return {"result": result_name, "url": url}
+        response = {"result": result_name, "url": url}
+        if spaces_info:
+            response["source_space_key"] = spaces_info["source_key"]
+            response["result_space_key"] = spaces_info["result_key"]
+        return response
     except Exception as e:
         status = "fail"
         error_msg = str(e)
@@ -1019,6 +1184,9 @@ def inpaint_url(req: InpaintRequest, request: Request, _: None = Depends(bearer_
             log_doc["appname"] = req.appname
         if error_msg:
             log_doc["error"] = error_msg
+        if spaces_info:
+            log_doc["source_space_key"] = spaces_info["source_key"]
+            log_doc["result_space_key"] = spaces_info["result_key"]
         if mongo_logs is not None:
             try:
                 log.info("Inserting log to MongoDB - Database: %s, Collection: %s", mongo_logs.database.name, mongo_logs.name)
@@ -1059,6 +1227,7 @@ def inpaint_multipart(
     status = "success"
     error_msg = None
     result_name = None
+    spaces_info = None
     
     try:
         # Handle appname="collage-maker": get category_id from collage-maker if not provided
@@ -1077,7 +1246,12 @@ def inpaint_multipart(
             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)
+            result_image = Image.fromarray(result)
+            result_image.save(result_path, "PNG", optimize=False, compress_level=1)
+            try:
+                spaces_info = _mirror_source_result_to_spaces(img, result_image)
+            except Exception as spaces_err:
+                log.error("Failed to mirror /inpaint-multipart passthrough images to DigitalOcean Spaces: %s", spaces_err, exc_info=True)
 
             url: Optional[str] = None
             try:
@@ -1093,6 +1267,9 @@ def inpaint_multipart(
             resp: Dict[str, str] = {"result": result_name}
             if url:
                 resp["url"] = url
+            if spaces_info:
+                resp["source_space_key"] = spaces_info["source_key"]
+                resp["result_space_key"] = spaces_info["result_key"]
             log_media_click(user_id, final_category_id, appname)
             return resp
 
@@ -1146,8 +1323,17 @@ def inpaint_multipart(
                 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"}
+                result_image = Image.fromarray(result)
+                result_image.save(result_path, "PNG", optimize=False, compress_level=1)
+                try:
+                    spaces_info = _mirror_source_result_to_spaces(img if img else m, result_image)
+                except Exception as spaces_err:
+                    log.error("Failed to mirror /inpaint-multipart fallback images to DigitalOcean Spaces: %s", spaces_err, exc_info=True)
+                response = {"result": result_name, "error": "pink/magenta paint detection failed - very few pixels detected"}
+                if spaces_info:
+                    response["source_space_key"] = spaces_info["source_key"]
+                    response["result_space_key"] = spaces_info["result_key"]
+                return response
             
             # Create binary mask: Pink pixels → white (255), Everything else → black (0)
             # Encode in RGBA format for process_inpaint
@@ -1178,7 +1364,12 @@ def inpaint_multipart(
         )
         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)
+        result_image = Image.fromarray(result)
+        result_image.save(result_path, "PNG", optimize=False, compress_level=1)
+        try:
+            spaces_info = _mirror_source_result_to_spaces(img, result_image)
+        except Exception as spaces_err:
+            log.error("Failed to mirror /inpaint-multipart images to DigitalOcean Spaces: %s", spaces_err, exc_info=True)
 
         url: Optional[str] = None
         try:
@@ -1194,6 +1385,9 @@ def inpaint_multipart(
         resp: Dict[str, str] = {"result": result_name}
         if url:
             resp["url"] = url
+        if spaces_info:
+            resp["source_space_key"] = spaces_info["source_key"]
+            resp["result_space_key"] = spaces_info["result_key"]
         log_media_click(user_id, final_category_id, appname)
         return resp
     except Exception as e:
@@ -1217,6 +1411,9 @@ def inpaint_multipart(
             log_doc["appname"] = appname
         if error_msg:
             log_doc["error"] = error_msg
+        if spaces_info:
+            log_doc["source_space_key"] = spaces_info["source_key"]
+            log_doc["result_space_key"] = spaces_info["result_key"]
         if mongo_logs is not None:
             try:
                 log.info("Inserting log to MongoDB - Database: %s, Collection: %s", mongo_logs.database.name, mongo_logs.name)
@@ -1258,6 +1455,7 @@ def remove_pink_segments(
     status = "success"
     error_msg = None
     result_name = None
+    spaces_info = None
     
     try:
         # Handle appname="collage-maker": get category_id from collage-maker if not provided
@@ -1303,11 +1501,20 @@ def remove_pink_segments(
             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_image = Image.fromarray(result)
+            result_image.save(result_path, "PNG", optimize=False, compress_level=1)
+            try:
+                spaces_info = _mirror_source_result_to_spaces(img, result_image)
+            except Exception as spaces_err:
+                log.error("Failed to mirror /remove-pink fallback images to DigitalOcean Spaces: %s", spaces_err, exc_info=True)
+            response = {
                 "result": result_name,
                 "error": "No pink/magenta segments detected. Please paint areas to remove with magenta/pink color (RGB 255,0,255)."
             }
+            if spaces_info:
+                response["source_space_key"] = spaces_info["source_key"]
+                response["result_space_key"] = spaces_info["result_key"]
+            return response
         
         # Create binary mask: Pink pixels → white (255), Everything else → black (0)
         # Encode in RGBA format that process_inpaint expects
@@ -1344,7 +1551,12 @@ def remove_pink_segments(
         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)
+        result_image = Image.fromarray(result)
+        result_image.save(result_path, "PNG", optimize=False, compress_level=1)
+        try:
+            spaces_info = _mirror_source_result_to_spaces(img, result_image)
+        except Exception as spaces_err:
+            log.error("Failed to mirror /remove-pink images to DigitalOcean Spaces: %s", spaces_err, exc_info=True)
         
         url: Optional[str] = None
         try:
@@ -1363,6 +1575,9 @@ def remove_pink_segments(
         resp: Dict[str, str] = {"result": result_name, "pink_segments_detected": str(nonzero)}
         if url:
             resp["url"] = url
+        if spaces_info:
+            resp["source_space_key"] = spaces_info["source_key"]
+            resp["result_space_key"] = spaces_info["result_key"]
         log_media_click(user_id, final_category_id, appname)
         return resp
     except Exception as e:
@@ -1386,6 +1601,9 @@ def remove_pink_segments(
             log_doc["appname"] = appname
         if error_msg:
             log_doc["error"] = error_msg
+        if spaces_info:
+            log_doc["source_space_key"] = spaces_info["source_key"]
+            log_doc["result_space_key"] = spaces_info["result_key"]
         if mongo_logs is not None:
             try:
                 log.info("Inserting log to MongoDB - Database: %s, Collection: %s", mongo_logs.database.name, mongo_logs.name)
@@ -1428,3 +1646,1434 @@ def view_result(filename: str):
 @app.get("/logs")
 def get_logs(_: None = Depends(bearer_auth)) -> JSONResponse:
     return JSONResponse(content=logs)
+
+# import os
+# import uuid
+# import shutil
+# import re
+# from datetime import datetime, timedelta, date
+# from io import BytesIO
+# from typing import Dict, List, Optional,Any
+# import numpy as np
+# from fastapi import (
+#     FastAPI,
+#     UploadFile,
+#     File,
+#     HTTPException,
+#     Depends,
+#     Header,
+#     Request,
+#     Form,
+# )
+# from fastapi.responses import FileResponse, JSONResponse
+# from pydantic import BaseModel
+# from PIL import Image, UnidentifiedImageError
+# import cv2
+# import logging
+# from gridfs import GridFS
+# from gridfs.errors import NoFile
+
+# from bson import ObjectId
+# from pymongo import MongoClient
+# import time
+
+# # Load environment variables from .env if present
+# try:
+#     from dotenv import load_dotenv
+
+#     load_dotenv()
+# except Exception:
+#     pass
+
+# logging.basicConfig(level=logging.INFO)
+# log = logging.getLogger("api")
+
+# from src.core import process_inpaint
+
+# # Directories (use writable space on HF Spaces)
+# BASE_DIR = os.environ.get("DATA_DIR", "/data")
+# if not os.path.isdir(BASE_DIR):
+#     # Fallback to /tmp if /data not available
+#     BASE_DIR = "/tmp"
+
+# UPLOAD_DIR = os.path.join(BASE_DIR, "uploads")
+# OUTPUT_DIR = os.path.join(BASE_DIR, "outputs")
+
+# os.makedirs(UPLOAD_DIR, exist_ok=True)
+# os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# # Optional Bearer token: set env API_TOKEN to require auth; if not set, endpoints are open
+# ENV_TOKEN = os.environ.get("API_TOKEN")
+
+# app = FastAPI(title="Photo Object Removal API", version="1.0.0")
+
+# # In-memory stores
+# file_store: Dict[str, Dict[str, str]] = {}
+# logs: List[Dict[str, str]] = []
+
+# MONGO_URI = os.environ.get("MONGO_URI") or os.environ.get("MONGODB_URI")
+# mongo_client = None
+# mongo_db = None
+# mongo_logs = None
+# grid_fs = None
+
+# if MONGO_URI:
+#     try:
+#         mongo_client = MongoClient(MONGO_URI)
+#         # Try to get database from connection string first
+#         try:
+#             mongo_db = mongo_client.get_default_database()
+#             log.info("Using database from connection string: %s", mongo_db.name)
+#         except Exception as db_err:
+#             mongo_db = None
+#             log.warning("Could not extract database from connection string: %s", db_err)
+        
+#         # Fallback to 'object_remover' if no database in connection string
+#         if mongo_db is None:
+#             mongo_db = mongo_client["object_remover"]
+#             log.info("Using default database: object_remover")
+        
+#         mongo_logs = mongo_db["api_logs"]
+#         grid_fs = GridFS(mongo_db)
+#         log.info("MongoDB connection initialized successfully - Database: %s, Collection: %s", mongo_db.name, mongo_logs.name)
+#     except Exception as err:
+#         log.error("Failed to initialize MongoDB connection: %s", err, exc_info=True)
+#         log.warning("GridFS operations will be disabled. Set MONGO_URI or MONGODB_URI environment variable.")
+# else:
+#     log.warning("MONGO_URI not set. GridFS operations will be disabled. Upload endpoints will not work.")
+# # if MONGO_URI:
+# #     try:
+# #         mongo_client = MongoClient(MONGO_URI)
+
+# #         # 🔥 FORCE DB + COLLECTION
+# #         mongo_db = mongo_client["logs"]
+# #         mongo_logs = mongo_db["objectRemover"]
+
+# #         log.info("MongoDB initialized → logs/objectRemover")
+# #     except Exception as err:
+# #         log.error("Failed to initialize MongoDB connection: %s", err, exc_info=True)
+# #         mongo_logs = None
+# # else:
+# #     log.warning("MONGO_URI not set. Logging disabled.")
+# # ✅ NEW: Separate Mongo for API Logs
+# API_LOGS_MONGO_URI = os.environ.get("API_LOGS_MONGODB_URL")
+
+# api_logs_client = None
+# api_logs_db = None
+# api_logs_collection = None
+
+# if API_LOGS_MONGO_URI:
+#     try:
+#         api_logs_client = MongoClient(API_LOGS_MONGO_URI)
+#         api_logs_db = api_logs_client["logs"]              # 🔥 logs database
+#         api_logs_collection = api_logs_db["objectRemover"] # 🔥 objectRemover collection
+#         log.info("API Logs Mongo initialized → logs/objectRemover")
+#     except Exception as e:
+#         log.error("Failed to initialize API Logs MongoDB: %s", e)
+#         api_logs_collection = None
+# else:
+#     log.warning("API_LOGS_MONGODB_URL not set. API logging disabled.")
+    
+# ADMIN_MONGO_URI = os.environ.get("MONGODB_ADMIN")
+# DEFAULT_CATEGORY_ID = "69368f722e46bd68ae188984"
+# admin_media_clicks = None
+
+# # Collage-maker MongoDB configuration
+# COLLAGE_MAKER_MONGO_URI = os.environ.get("MONGODB_COLLAGE_MAKER")
+# COLLAGE_MAKER_DB_NAME = os.environ.get("MONGODB_COLLAGE_MAKER_DB_NAME", "collage-maker")
+# COLLAGE_MAKER_ADMIN_DB_NAME = os.environ.get("MONGODB_COLLAGE_MAKER_ADMIN_DB_NAME", "adminPanel")
+# collage_maker_client = None
+# collage_maker_db = None
+# collage_maker_admin_db = None
+# collage_maker_media_clicks = None
+# collage_maker_categories = None
+
+# # AI-Enhancer MongoDB configuration
+# AI_ENHANCER_MONGO_URI = os.environ.get("MONGODB_AI_ENHANCER")
+# AI_ENHANCER_DB_NAME = os.environ.get("MONGODB_AI_ENHANCER_DB_NAME", "ai-enhancer")
+# AI_ENHANCER_ADMIN_DB_NAME = os.environ.get("MONGODB_AI_ENHANCER_ADMIN_DB_NAME", "test")
+# ai_enhancer_client = None
+# ai_enhancer_db = None
+# ai_enhancer_admin_db = None
+# ai_enhancer_media_clicks = None
+
+
+# def get_collage_maker_client() -> Optional[MongoClient]:
+#     """Get collage-maker MongoDB client."""
+#     global collage_maker_client
+#     if collage_maker_client is None and COLLAGE_MAKER_MONGO_URI:
+#         try:
+#             collage_maker_client = MongoClient(COLLAGE_MAKER_MONGO_URI)
+#             log.info("Collage-maker MongoDB client initialized")
+#         except Exception as err:
+#             log.error("Failed to initialize collage-maker MongoDB client: %s", err)
+#             collage_maker_client = None
+#     return collage_maker_client
+
+
+# def get_collage_maker_database() -> Optional[Any]:
+#     """Get collage-maker database instance."""
+#     global collage_maker_db
+#     client = get_collage_maker_client()
+#     if client is None:
+#         return None
+#     if collage_maker_db is None:
+#         try:
+#             collage_maker_db = client[COLLAGE_MAKER_DB_NAME]
+#             log.info("Collage-maker database initialized: %s", COLLAGE_MAKER_DB_NAME)
+#         except Exception as err:
+#             log.error("Failed to get collage-maker database: %s", err)
+#             collage_maker_db = None
+#     return collage_maker_db
+
+
+# def _init_collage_maker_mongo() -> None:
+#     """Initialize collage-maker MongoDB connections."""
+#     global collage_maker_admin_db, collage_maker_media_clicks, collage_maker_categories
+#     client = get_collage_maker_client()
+#     if client is None:
+#         log.info("Collage-maker Mongo URI not provided; collage-maker features disabled")
+#         return
+#     try:
+#         collage_maker_admin_db = client[COLLAGE_MAKER_ADMIN_DB_NAME]
+#         collage_maker_media_clicks = collage_maker_admin_db["media_clicks"]
+#         collage_maker_categories = collage_maker_admin_db["categories"]
+#         log.info(
+#             "Collage-maker admin initialized: db=%s, media_clicks=%s, categories=%s",
+#             COLLAGE_MAKER_ADMIN_DB_NAME,
+#             collage_maker_media_clicks.name,
+#             collage_maker_categories.name,
+#         )
+#     except Exception as err:
+#         log.error("Failed to init collage-maker admin Mongo: %s", err)
+#         collage_maker_admin_db = None
+#         collage_maker_media_clicks = None
+#         collage_maker_categories = None
+
+
+# _init_collage_maker_mongo()
+
+
+# def get_ai_enhancer_client() -> Optional[MongoClient]:
+#     """Get AI-Enhancer MongoDB client."""
+#     global ai_enhancer_client
+#     if ai_enhancer_client is None and AI_ENHANCER_MONGO_URI:
+#         try:
+#             ai_enhancer_client = MongoClient(AI_ENHANCER_MONGO_URI)
+#             log.info("AI-Enhancer MongoDB client initialized")
+#         except Exception as err:
+#             log.error("Failed to initialize AI-Enhancer MongoDB client: %s", err)
+#             ai_enhancer_client = None
+#     return ai_enhancer_client
+
+
+# def get_ai_enhancer_database() -> Optional[Any]:
+#     """Get AI-Enhancer database instance."""
+#     global ai_enhancer_db
+#     client = get_ai_enhancer_client()
+#     if client is None:
+#         return None
+#     if ai_enhancer_db is None:
+#         try:
+#             ai_enhancer_db = client[AI_ENHANCER_DB_NAME]
+#             log.info("AI-Enhancer database initialized: %s", AI_ENHANCER_DB_NAME)
+#         except Exception as err:
+#             log.error("Failed to get AI-Enhancer database: %s", err)
+#             ai_enhancer_db = None
+#     return ai_enhancer_db
+
+
+# def _init_ai_enhancer_mongo() -> None:
+#     """Initialize AI-Enhancer MongoDB connections."""
+#     global ai_enhancer_admin_db, ai_enhancer_media_clicks
+#     client = get_ai_enhancer_client()
+#     if client is None:
+#         log.info("AI-Enhancer Mongo URI not provided; AI-Enhancer features disabled")
+#         return
+#     try:
+#         ai_enhancer_admin_db = client[AI_ENHANCER_ADMIN_DB_NAME]
+#         ai_enhancer_media_clicks = ai_enhancer_admin_db["media_clicks"]
+#         log.info(
+#             "AI-Enhancer admin initialized: db=%s, media_clicks=%s",
+#             AI_ENHANCER_ADMIN_DB_NAME,
+#             ai_enhancer_media_clicks.name,
+#         )
+#     except Exception as err:
+#         log.error("Failed to init AI-Enhancer admin Mongo: %s", err)
+#         ai_enhancer_admin_db = None
+#         ai_enhancer_media_clicks = None
+
+
+# _init_ai_enhancer_mongo()
+
+
+# def get_category_id_from_collage_maker() -> Optional[str]:
+#     """Query category ID from collage-maker categories collection."""
+#     if collage_maker_categories is None:
+#         log.warning("Collage-maker categories collection not initialized")
+#         return None
+#     try:
+#         # Query the categories collection - you may need to adjust the query based on your schema
+#         # This assumes there's a default category or we get the first one
+#         category_doc = collage_maker_categories.find_one()
+#         if category_doc:
+#             category_id = str(category_doc.get("_id", ""))
+#             log.info("Found category ID from collage-maker: %s", category_id)
+#             return category_id
+#         else:
+#             log.warning("No categories found in collage-maker collection")
+#             return None
+#     except Exception as err:
+#         log.error("Failed to query collage-maker categories: %s", err)
+#         return None
+
+
+# def _init_admin_mongo() -> None:
+#     global admin_media_clicks
+#     if not ADMIN_MONGO_URI:
+#         log.info("Admin Mongo URI not provided; media click logging disabled")
+#         return
+#     try:
+#         admin_client = MongoClient(ADMIN_MONGO_URI)
+#         # get_default_database() extracts database from connection string (e.g., /adminPanel)
+#         try:
+#             admin_db = admin_client.get_default_database()
+#         except Exception as db_err:
+#             admin_db = None
+#             log.warning("Admin Mongo URI has no default DB; error=%s", db_err)
+#         if admin_db is None:
+#             # Fallback to provided default for this app
+#             admin_db = admin_client["object_remover"]
+#             log.warning("No database in connection string, defaulting to 'object_remover'")
+        
+#         admin_media_clicks = admin_db["media_clicks"]
+#         log.info(
+#             "Admin media click logging initialized: db=%s collection=%s",
+#             admin_db.name,
+#             admin_media_clicks.name,
+#         )
+#         try:
+#             admin_media_clicks.drop_index("user_id_1_header_1_media_id_1")
+#             log.info("Dropped legacy index user_id_1_header_1_media_id_1")
+#         except Exception as idx_err:
+#             # Index drop failure is non-critical (often permission issue)
+#             if "Unauthorized" not in str(idx_err):
+#                 log.info("Skipping legacy index drop: %s", idx_err)
+#     except Exception as err:
+#         log.error("Failed to init admin Mongo client: %s", err)
+#         admin_media_clicks = None
+
+
+# _init_admin_mongo()
+
+
+# def _admin_logging_status() -> Dict[str, object]:
+#     if admin_media_clicks is None:
+#         return {
+#             "enabled": False,
+#             "db": None,
+#             "collection": None,
+#         }
+#     return {
+#         "enabled": True,
+#         "db": admin_media_clicks.database.name,
+#         "collection": admin_media_clicks.name,
+#     }
+
+
+# def _save_upload_to_gridfs(upload: UploadFile, file_type: str) -> str:
+#     """Store an uploaded file into GridFS and return its ObjectId string."""
+#     if grid_fs is None:
+#         raise HTTPException(
+#             status_code=503,
+#             detail="MongoDB/GridFS not configured. Set MONGO_URI or MONGODB_URI environment variable."
+#         )
+#     data = upload.file.read()
+#     if not data:
+#         raise HTTPException(status_code=400, detail=f"{file_type} file is empty")
+#     oid = grid_fs.put(
+#         data,
+#         filename=upload.filename or f"{file_type}.bin",
+#         contentType=upload.content_type,
+#         metadata={"type": file_type},
+#     )
+#     return str(oid)
+
+
+# def _read_gridfs_bytes(file_id: str, expected_type: str) -> bytes:
+#     """Fetch raw bytes from GridFS and validate the stored type metadata."""
+#     if grid_fs is None:
+#         raise HTTPException(
+#             status_code=503,
+#             detail="MongoDB/GridFS not configured. Set MONGO_URI or MONGODB_URI environment variable."
+#         )
+#     try:
+#         oid = ObjectId(file_id)
+#     except Exception:
+#         raise HTTPException(status_code=404, detail=f"{expected_type}_id invalid")
+
+#     try:
+#         grid_out = grid_fs.get(oid)
+#     except NoFile:
+#         raise HTTPException(status_code=404, detail=f"{expected_type}_id not found")
+
+#     meta = grid_out.metadata or {}
+#     stored_type = meta.get("type")
+#     if stored_type and stored_type != expected_type:
+#         raise HTTPException(status_code=404, detail=f"{expected_type}_id not found")
+
+#     return grid_out.read()
+
+
+# def _load_rgba_image_from_gridfs(file_id: str, expected_type: str) -> Image.Image:
+#     """Load an image from GridFS and convert to RGBA."""
+#     data = _read_gridfs_bytes(file_id, expected_type)
+#     try:
+#         img = Image.open(BytesIO(data))
+#     except UnidentifiedImageError:
+#         raise HTTPException(status_code=422, detail=f"{expected_type} is not a valid image")
+#     return img.convert("RGBA")
+
+
+# def _build_ai_edit_daily_count(
+#     existing: Optional[List[Dict[str, object]]],
+#     today: date,
+# ) -> List[Dict[str, object]]:
+#     """
+#     Build / extend the ai_edit_daily_count array with the following rules:
+
+#     - Case A (no existing data): return [{date: today, count: 1}]
+#     - Case B (today already recorded): return list unchanged
+#     - Case C (gap in days): fill missing days with count=0 and append today with count=1
+
+#     Additionally, the returned list is capped to the most recent 32 entries.
+
+#     The stored "date" value is a midnight UTC (naive UTC) datetime for the given day.
+#     """
+
+#     def _to_date_only(value: object) -> date:
+#         if isinstance(value, datetime):
+#             return value.date()
+#         if isinstance(value, date):
+#             return value
+#         # Fallback: try parsing ISO string "YYYY-MM-DD" or full datetime
+#         try:
+#             text = str(value)
+#             if len(text) == 10:
+#                 return datetime.strptime(text, "%Y-%m-%d").date()
+#             return datetime.fromisoformat(text).date()
+#         except Exception:
+#             # If parsing fails, just treat as today to avoid crashing
+#             return today
+
+#     # Case A: first ever use (no array yet)
+#     if not existing:
+#         return [
+#             {
+#                 "date": datetime(today.year, today.month, today.day),
+#                 "count": 1,
+#             }
+#         ]
+
+#     # Work on a shallow copy so we don't mutate original in-place
+#     result: List[Dict[str, object]] = list(existing)
+
+#     last_entry = result[-1] if result else None
+#     if not last_entry or "date" not in last_entry:
+#         # If structure is unexpected, re-initialize safely
+#         return [
+#             {
+#                 "date": datetime(today.year, today.month, today.day),
+#                 "count": 1,
+#             }
+#         ]
+
+#     last_date = _to_date_only(last_entry["date"])
+
+#     # If somehow the last stored date is in the future, do nothing to avoid corrupting history
+#     if last_date > today:
+#         return result
+
+#     # Case B: today's date already present as the last entry → unchanged
+#     if last_date == today:
+#         return result
+
+#     # Case C: there is a gap, fill missing days with count=0 and append today with count=1
+#     cursor = last_date + timedelta(days=1)
+#     while cursor < today:
+#         result.append(
+#             {
+#                 "date": datetime(cursor.year, cursor.month, cursor.day),
+#                 "count": 0,
+#             }
+#         )
+#         cursor += timedelta(days=1)
+
+#     # Finally add today's presence indicator
+#     result.append(
+#         {
+#             "date": datetime(today.year, today.month, today.day),
+#             "count": 1,
+#         }
+#     )
+
+#     # Sort by date ascending (older dates first) to guarantee stable ordering:
+#     # [oldest, ..., newest]
+#     try:
+#         result.sort(key=lambda entry: _to_date_only(entry.get("date")))
+#     except Exception:
+#         # If anything goes wrong during sort, fall back to current ordering
+#         pass
+
+#     # Enforce 32-entry limit (keep the most recent 32 days)
+#     if len(result) > 32:
+#         result = result[-32:]
+
+#     return result
+
+# def bearer_auth(authorization: Optional[str] = Header(default=None)) -> None:
+#     if not ENV_TOKEN:
+#         return
+#     if authorization is None or not authorization.lower().startswith("bearer "):
+#         raise HTTPException(status_code=401, detail="Unauthorized")
+#     token = authorization.split(" ", 1)[1]
+#     if token != ENV_TOKEN:
+#         raise HTTPException(status_code=403, detail="Forbidden")
+
+
+# class InpaintRequest(BaseModel):
+#     image_id: str
+#     mask_id: str
+#     invert_mask: bool = True  # True => selected/painted area is removed
+#     passthrough: bool = False  # If True, return the original image unchanged
+#     prompt: Optional[str] = None  # Optional: describe what to remove
+#     user_id: Optional[str] = None
+#     category_id: Optional[str] = None
+#     appname: Optional[str] = None  # Optional: app name (e.g., "collage-maker")
+
+
+# class SimpleRemoveRequest(BaseModel):
+#     image_id: str  # Image with pink/magenta segments to remove
+
+
+# def _coerce_object_id(value: Optional[str]) -> ObjectId:
+#     if value is None:
+#         return ObjectId()
+#     value_str = str(value).strip()
+#     if re.fullmatch(r"[0-9a-fA-F]{24}", value_str):
+#         return ObjectId(value_str)
+#     if value_str.isdigit():
+#         hex_str = format(int(value_str), "x")
+#         if len(hex_str) > 24:
+#             hex_str = hex_str[-24:]
+#         hex_str = hex_str.rjust(24, "0")
+#         return ObjectId(hex_str)
+#     return ObjectId()
+
+
+# def _coerce_category_id(category_id: Optional[str]) -> ObjectId:
+#     raw = category_id or DEFAULT_CATEGORY_ID
+#     raw_str = str(raw).strip()
+#     if re.fullmatch(r"[0-9a-fA-F]{24}", raw_str):
+#         return ObjectId(raw_str)
+#     return _coerce_object_id(raw_str)
+
+
+# def log_media_click(user_id: Optional[str], category_id: Optional[str], appname: Optional[str] = None) -> None:
+#     """Log to admin media_clicks collection only if user_id is provided.
+    
+#     If appname='collage-maker', logs to collage-maker MongoDB instead of regular admin MongoDB.
+#     If appname='AI-Enhancer' (case-insensitive), logs to AI-Enhancer MongoDB.
+#     """
+#     # Determine which media_clicks collection to use
+#     target_media_clicks = None
+#     appname_lower = appname.lower() if appname else None
+    
+#     if appname_lower == "collage-maker":
+#         target_media_clicks = collage_maker_media_clicks
+#         if target_media_clicks is None:
+#             log.warning("Collage-maker media_clicks not initialized, skipping log")
+#             return
+#     elif appname_lower == "ai-enhancer":
+#         target_media_clicks = ai_enhancer_media_clicks
+#         if target_media_clicks is None:
+#             log.warning("AI-Enhancer media_clicks not initialized, skipping log")
+#             return
+#     else:
+#         target_media_clicks = admin_media_clicks
+#         if target_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)
+#         now = datetime.utcnow()
+#         today = now.date()
+
+#         doc = target_media_clicks.find_one({"userId": user_obj})
+#         if doc:
+#             existing_daily = doc.get("ai_edit_daily_count")
+#             updated_daily = _build_ai_edit_daily_count(existing_daily, today)
+#             categories = doc.get("categories") or []
+#             if any(cat.get("categoryId") == category_obj for cat in categories):
+#                 # Category exists: increment click_count and ai_edit_complete, update dates
+#                 target_media_clicks.update_one(
+#                     {"_id": doc["_id"], "categories.categoryId": category_obj},
+#                     {
+#                         "$inc": {
+#                             "categories.$.click_count": 1,
+#                             "ai_edit_complete": 1,  # $inc handles missing fields (backward compatible)
+#                         },
+#                         "$set": {
+#                             "categories.$.lastClickedAt": now,
+#                             "updatedAt": now,
+#                             "ai_edit_last_date": now,
+#                             "ai_edit_daily_count": updated_daily,
+#                         },
+#                     },
+#                 )
+#             else:
+#                 # New category to existing document: push category, increment ai_edit_complete
+#                 target_media_clicks.update_one(
+#                     {"_id": doc["_id"]},
+#                     {
+#                         "$push": {
+#                             "categories": {
+#                                 "categoryId": category_obj,
+#                                 "click_count": 1,
+#                                 "lastClickedAt": now,
+#                             }
+#                         },
+#                         "$inc": {"ai_edit_complete": 1},  # $inc handles missing fields
+#                         "$set": {
+#                             "updatedAt": now,
+#                             "ai_edit_last_date": now,
+#                             "ai_edit_daily_count": updated_daily,
+#                         },
+#                     },
+#                 )
+#         else:
+#             # New user: create document with default ai_edit_complete=0, then increment to 1
+#             daily_for_new = _build_ai_edit_daily_count(None, today)
+#             target_media_clicks.update_one(
+#                 {"userId": user_obj},
+#                 {
+#                     "$setOnInsert": {
+#                         "userId": user_obj,
+#                         "categories": [
+#                             {
+#                                 "categoryId": category_obj,
+#                                 "click_count": 1,
+#                                 "lastClickedAt": now,
+#                             }
+#                         ],
+#                         "createdAt": now,
+#                         "ai_edit_daily_count": daily_for_new,
+#                     },
+#                     "$inc": {"ai_edit_complete": 1},  # Increment to 1 on first use
+#                     "$set": {
+#                         "updatedAt": now,
+#                         "ai_edit_last_date": now,
+#                     },
+#                 },
+#                 upsert=True,
+#             )
+#     except Exception as err:
+#         err_str = str(err)
+#         appname_lower = appname.lower() if appname else None
+#         if appname_lower == "collage-maker":
+#             target_name = "collage-maker"
+#         elif appname_lower == "ai-enhancer":
+#             target_name = "AI-Enhancer"
+#         else:
+#             target_name = "admin"
+#         if "Unauthorized" in err_str or "not authorized" in err_str.lower():
+#             log.warning(
+#                 "%s media click logging failed (permissions): user lacks read/write on db=%s collection=%s. "
+#                 "Check MongoDB user permissions.",
+#                 target_name,
+#                 target_media_clicks.database.name,
+#                 target_media_clicks.name,
+#             )
+#         else:
+#             log.warning("%s media click logging failed: %s", target_name, err)
+
+
+# @app.get("/")
+# def root() -> Dict[str, Any]:
+#     return {
+#         "success": True,
+#         "message": "Object Remover API",
+#         "data": {
+#             "version": "1.0.0",
+#             "product_name": "Beauty Camera - GlowCam AI Studio",
+#             "released_by": "LogicGo Infotech"
+#         }
+#     }
+
+
+
+# @app.get("/health")
+# def health() -> Dict[str, str]:
+#     return {"status": "healthy"}
+
+
+# @app.get("/logging-status")
+# def logging_status(_: None = Depends(bearer_auth)) -> Dict[str, object]:
+#     """Helper endpoint to verify admin media logging wiring (no secrets exposed)."""
+#     return _admin_logging_status()
+
+
+# @app.get("/mongo-status")
+# def mongo_status(_: None = Depends(bearer_auth)) -> Dict[str, object]:
+#     """Check MongoDB connection status and verify data storage."""
+#     status = {
+#         "mongo_configured": MONGO_URI is not None,
+#         "mongo_connected": mongo_client is not None,
+#         "database": mongo_db.name if mongo_db else None,
+#         "collection": mongo_logs.name if mongo_logs else None,
+#         "admin_logging": _admin_logging_status(),
+#     }
+    
+#     # Try to count documents in api_logs collection
+#     if mongo_logs is not None:
+#         try:
+#             count = mongo_logs.count_documents({})
+#             status["api_logs_count"] = count
+#             # Get latest 5 documents
+#             latest_docs = list(mongo_logs.find().sort("timestamp", -1).limit(5))
+#             status["recent_logs"] = []
+#             for doc in latest_docs:
+#                 doc_dict = {
+#                     "_id": str(doc.get("_id")),
+#                     "output_id": doc.get("output_id"),
+#                     "status": doc.get("status"),
+#                     "timestamp": doc.get("timestamp").isoformat() if isinstance(doc.get("timestamp"), datetime) else str(doc.get("timestamp")),
+#                 }
+#                 if "input_image_id" in doc:
+#                     doc_dict["input_image_id"] = doc.get("input_image_id")
+#                 if "input_mask_id" in doc:
+#                     doc_dict["input_mask_id"] = doc.get("input_mask_id")
+#                 if "error" in doc:
+#                     doc_dict["error"] = doc.get("error")
+#                 status["recent_logs"].append(doc_dict)
+            
+#             # Get latest document for backward compatibility
+#             if latest_docs:
+#                 latest = latest_docs[0]
+#                 status["latest_log"] = {
+#                     "_id": str(latest.get("_id")),
+#                     "output_id": latest.get("output_id"),
+#                     "status": latest.get("status"),
+#                     "timestamp": latest.get("timestamp").isoformat() if isinstance(latest.get("timestamp"), datetime) else str(latest.get("timestamp")),
+#                 }
+#         except Exception as err:
+#             status["api_logs_error"] = str(err)
+#             log.error("Error querying MongoDB: %s", err, exc_info=True)
+    
+#     return status
+
+
+# @app.post("/upload-image")
+# def upload_image(image: UploadFile = File(...), _: None = Depends(bearer_auth)) -> Dict[str, str]:
+#     file_id = _save_upload_to_gridfs(image, "image")
+#     logs.append({"id": file_id, "filename": image.filename, "type": "image", "timestamp": datetime.utcnow().isoformat()})
+#     return {"id": file_id, "filename": image.filename}
+
+
+# @app.post("/upload-mask")
+# def upload_mask(mask: UploadFile = File(...), _: None = Depends(bearer_auth)) -> Dict[str, str]:
+#     file_id = _save_upload_to_gridfs(mask, "mask")
+#     logs.append({"id": file_id, "filename": mask.filename, "type": "mask", "timestamp": datetime.utcnow().isoformat()})
+#     return {"id": file_id, "filename": mask.filename}
+
+
+# def _compress_image(image_path: str, output_path: str, quality: int = 85) -> None:
+#     """
+#     Compress an image to reduce file size.
+#     Converts to JPEG format with specified quality to achieve smaller file size.
+#     """
+#     img = Image.open(image_path)
+#     # Convert RGBA to RGB if needed (JPEG doesn't support alpha)
+#     if img.mode == "RGBA":
+#         rgb_img = Image.new("RGB", img.size, (255, 255, 255))
+#         rgb_img.paste(img, mask=img.split()[3])  # Use alpha channel as mask
+#         img = rgb_img
+#     elif img.mode != "RGB":
+#         img = img.convert("RGB")
+    
+#     # Save as JPEG with quality setting for compression
+#     img.save(output_path, "JPEG", quality=quality, optimize=True)
+
+
+# def _load_rgba_mask_from_image(img: Image.Image) -> np.ndarray:
+#     """
+#     Convert mask image to RGBA format (black/white mask).
+#     Standard convention: white (255) = area to remove, black (0) = area to keep
+#     Returns RGBA with white in RGB channels where removal is needed, alpha=255
+#     """
+#     if img.mode != "RGBA":
+#         # For RGB/Grayscale masks: white (value>128) = remove, black (value<=128) = keep
+#         gray = img.convert("L")
+#         arr = np.array(gray)
+#         # Create proper black/white mask: white pixels (>128) = remove, black (<=128) = keep
+#         mask_bw = np.where(arr > 128, 255, 0).astype(np.uint8)
+        
+#         rgba = np.zeros((img.height, img.width, 4), dtype=np.uint8)
+#         rgba[:, :, 0] = mask_bw  # R
+#         rgba[:, :, 1] = mask_bw  # G
+#         rgba[:, :, 2] = mask_bw  # B
+#         rgba[:, :, 3] = 255  # Fully opaque
+#         log.info(f"Loaded {img.mode} mask: {int((mask_bw > 0).sum())} white pixels (to remove)")
+#         return rgba
+    
+#     # For RGBA: check if alpha channel is meaningful
+#     arr = np.array(img)
+#     alpha = arr[:, :, 3]
+#     rgb = arr[:, :, :3]
+    
+#     # If alpha is mostly opaque everywhere (mean > 200), treat RGB channels as mask values
+#     if alpha.mean() > 200:
+#         # Use RGB to determine mask: white/bright in RGB = remove
+#         gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
+#         # Also detect magenta specifically
+#         magenta = np.all(rgb == [255, 0, 255], axis=2).astype(np.uint8) * 255
+#         mask_bw = np.maximum(np.where(gray > 128, 255, 0).astype(np.uint8), magenta)
+        
+#         rgba = arr.copy()
+#         rgba[:, :, 0] = mask_bw  # R
+#         rgba[:, :, 1] = mask_bw  # G
+#         rgba[:, :, 2] = mask_bw  # B
+#         rgba[:, :, 3] = 255  # Fully opaque
+#         log.info(f"Loaded RGBA mask (RGB-based): {int((mask_bw > 0).sum())} white pixels (to remove)")
+#         return rgba
+    
+#     # Alpha channel encodes the mask - convert to RGB-based
+#     # Transparent areas (alpha < 128) = remove, Opaque areas = keep
+#     mask_bw = np.where(alpha < 128, 255, 0).astype(np.uint8)
+#     rgba = arr.copy()
+#     rgba[:, :, 0] = mask_bw
+#     rgba[:, :, 1] = mask_bw
+#     rgba[:, :, 2] = mask_bw
+#     rgba[:, :, 3] = 255
+#     log.info(f"Loaded RGBA mask (alpha-based): {int((mask_bw > 0).sum())} white pixels (to remove)")
+#     return rgba
+
+# @app.post("/inpaint")
+# def inpaint(req: InpaintRequest, request: Request, _: None = Depends(bearer_auth)) -> Dict[str, str]:
+#     start_time = time.time()
+#     status = "success"
+#     error_msg = None
+#     output_name = None
+#     compressed_url = None
+
+#     try:
+#         # Handle appname="collage-maker": get category_id from collage-maker if not provided
+#         category_id = req.category_id
+#         if req.appname == "collage-maker" and not category_id:
+#             category_id = get_category_id_from_collage_maker()
+#             if category_id:
+#                 log.info("Using category_id from collage-maker: %s", category_id)
+
+#         img_rgba = _load_rgba_image_from_gridfs(req.image_id, "image")
+#         mask_img = _load_rgba_image_from_gridfs(req.mask_id, "mask")
+#         mask_rgba = _load_rgba_mask_from_image(mask_img)
+
+#         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,
+#                 prompt=req.prompt,
+#             )
+
+#         output_name = f"output_{uuid.uuid4().hex}.png"
+#         output_path = os.path.join(OUTPUT_DIR, output_name)
+
+#         Image.fromarray(result).save(
+#             output_path, "PNG", optimize=False, compress_level=1
+#         )
+
+#         # Create compressed version
+#         compressed_name = f"compressed_{output_name.replace('.png', '.jpg')}"
+#         compressed_path = os.path.join(OUTPUT_DIR, compressed_name)
+#         try:
+#             # _compress_image(output_path, compressed_path, quality=85)
+#             # # compressed_url = str(request.url_for("download_file", filename=compressed_name))
+#             # compressed_url = str(request.url_for("download_file", filename=compressed_name).replace("http://", "https://"))
+#             _compress_image(output_path, compressed_path, quality=85)
+#             compressed_url = str(
+#                 request.url_for("download_file", filename=compressed_name)
+#             ).replace("http://", "https://")
+#         except Exception as compress_err:
+#             log.warning("Failed to create compressed image: %s", compress_err)
+#             compressed_url = None
+
+#         log_media_click(req.user_id, category_id, req.appname)
+#         response = {"result": output_name}
+#         if compressed_url:
+#             response["Compressed_Image_URL"] = compressed_url
+#         return response
+
+#     except Exception as e:
+#         status = "fail"
+#         error_msg = str(e)
+#         raise
+
+#     finally:
+#         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": output_name,
+#         #     "status": status,
+#         #     "timestamp": datetime.utcnow(),
+#         #     "ts": int(time.time()),
+#         #     "response_time_ms": response_time_ms
+#         # }
+#         log_doc = {
+#             "endpoint": "/inpaint",
+#             "status": status,
+#             "response_time_ms": float(response_time_ms),
+#             "timestamp": datetime.utcnow(),
+#             "appname": req.appname if req.appname else "None",
+#             "error": error_msg
+#         }
+
+#         # Store appname in api_logs if provided
+#         if req.appname:
+#             log_doc["appname"] = req.appname
+
+#         if error_msg:
+#             log_doc["error"] = error_msg
+
+#         # if mongo_logs is not None:
+#         #     try:
+#         #         log.info("Inserting log to MongoDB - Database: %s, Collection: %s", mongo_logs.database.name, mongo_logs.name)
+#         #         log.debug("Log document: %s", log_doc)
+#         #         result = mongo_logs.insert_one(log_doc)
+#         #         log.info("Mongo log inserted successfully: _id=%s, output_id=%s, status=%s, db=%s, collection=%s", 
+#         #                 result.inserted_id, output_name, status, mongo_logs.database.name, mongo_logs.name)
+                
+#         #         # Verify the insert by reading it back
+#         #         try:
+#         #             verify_doc = mongo_logs.find_one({"_id": result.inserted_id})
+#         #             if verify_doc:
+#         #                 log.info("Verified: Document exists in MongoDB after insert")
+#         #             else:
+#         #                 log.error("WARNING: Document not found after insert! _id=%s", result.inserted_id)
+#         #         except Exception as verify_err:
+#         #             log.warning("Could not verify insert: %s", verify_err)
+#         #     except Exception as mongo_err:
+#         #         log.error("Mongo log insert failed: %s, log_doc=%s", mongo_err, log_doc, exc_info=True)
+#         # else:
+#         #     log.warning("MongoDB not configured, skipping log insert")
+#         if api_logs_collection is not None:
+#             try:
+#                 api_logs_collection.insert_one(log_doc)
+#                 log.info("API log inserted into logs/objectRemover")
+#             except Exception as e:
+#                 log.error("Failed to insert API log: %s", e)
+
+# # @app.post("/inpaint")
+# # def inpaint(req: InpaintRequest, _: None = Depends(bearer_auth)) -> Dict[str, str]:
+# #     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")
+
+# #     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)
+
+# #     # Debug: check mask before processing
+# #     white_pixels = int((mask_rgba[:,:,0] > 128).sum())
+# #     log.info(f"Inpaint request: mask has {white_pixels} white pixels, invert_mask={req.invert_mask}")
+
+# #     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)
+
+# #     logs.append({"result": result_name, "timestamp": datetime.utcnow().isoformat()})
+# #     return {"result": result_name}
+
+
+# @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."""
+#     start_time = time.time()
+#     status = "success"
+#     error_msg = None
+#     result_name = None
+
+#     try:
+#         # Handle appname="collage-maker": get category_id from collage-maker if not provided
+#         category_id = req.category_id
+#         if req.appname == "collage-maker" and not category_id:
+#             category_id = get_category_id_from_collage_maker()
+#             if category_id:
+#                 log.info("Using category_id from collage-maker: %s", category_id)
+
+#         img_rgba = _load_rgba_image_from_gridfs(req.image_id, "image")
+#         mask_img = _load_rgba_image_from_gridfs(req.mask_id, "mask")  # may be RGB/gray/RGBA
+#         mask_rgba = _load_rgba_mask_from_image(mask_img)
+
+#         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,
+#                 prompt=req.prompt,
+#             )
+#         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, category_id, req.appname)
+#         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,
+#         }
+#         # Store appname in api_logs if provided
+#         if req.appname:
+#             log_doc["appname"] = req.appname
+#         if error_msg:
+#             log_doc["error"] = error_msg
+#         if mongo_logs is not None:
+#             try:
+#                 log.info("Inserting log to MongoDB - Database: %s, Collection: %s", mongo_logs.database.name, mongo_logs.name)
+#                 result = mongo_logs.insert_one(log_doc)
+#                 log.info("Mongo log inserted successfully: _id=%s, output_id=%s, status=%s, db=%s, collection=%s", 
+#                         result.inserted_id, output_name, status, mongo_logs.database.name, mongo_logs.name)
+                
+#                 # Verify the insert by reading it back
+#                 try:
+#                     verify_doc = mongo_logs.find_one({"_id": result.inserted_id})
+#                     if verify_doc:
+#                         log.info("Verified: Document exists in MongoDB after insert")
+#                     else:
+#                         log.error("WARNING: Document not found after insert! _id=%s", result.inserted_id)
+#                 except Exception as verify_err:
+#                     log.warning("Could not verify insert: %s", verify_err)
+#             except Exception as mongo_err:
+#                 log.error("Mongo log insert failed: %s, log_doc=%s", mongo_err, log_doc, exc_info=True)
+#         else:
+#             log.warning("MongoDB not configured, skipping log insert")
+
+
+# @app.post("/inpaint-multipart")
+# def inpaint_multipart(
+#     image: UploadFile = File(...),
+#     mask: UploadFile = File(...),
+#     request: Request = None,
+#     invert_mask: bool = True,
+#     mask_is_painted: bool = False,  # if True, mask file is the painted-on image (e.g., black strokes on original)
+#     passthrough: bool = False,
+#     prompt: Optional[str] = Form(None),
+#     user_id: Optional[str] = Form(None),
+#     category_id: Optional[str] = Form(None),
+#     appname: Optional[str] = Form(None),
+#     _: None = Depends(bearer_auth),
+# ) -> Dict[str, str]:
+#     start_time = time.time()
+#     status = "success"
+#     error_msg = None
+#     result_name = None
+    
+#     try:
+#         # Handle appname="collage-maker": get category_id from collage-maker if not provided
+#         final_category_id = category_id
+#         if appname == "collage-maker" and not final_category_id:
+#             final_category_id = get_category_id_from_collage_maker()
+#             if final_category_id:
+#                 log.info("Using category_id from collage-maker: %s", final_category_id)
+        
+#         # 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, final_category_id, appname)
+#             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)
+
+#         # 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,
+#             prompt=prompt,
+#         )
+#         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, final_category_id, appname)
+#         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,
+#         }
+#         # Store appname in api_logs if provided
+#         if appname:
+#             log_doc["appname"] = appname
+#         if error_msg:
+#             log_doc["error"] = error_msg
+#         if mongo_logs is not None:
+#             try:
+#                 log.info("Inserting log to MongoDB - Database: %s, Collection: %s", mongo_logs.database.name, mongo_logs.name)
+#                 result = mongo_logs.insert_one(log_doc)
+#                 log.info("Mongo log inserted successfully: _id=%s, output_id=%s, status=%s, db=%s, collection=%s", 
+#                         result.inserted_id, output_name, status, mongo_logs.database.name, mongo_logs.name)
+                
+#                 # Verify the insert by reading it back
+#                 try:
+#                     verify_doc = mongo_logs.find_one({"_id": result.inserted_id})
+#                     if verify_doc:
+#                         log.info("Verified: Document exists in MongoDB after insert")
+#                     else:
+#                         log.error("WARNING: Document not found after insert! _id=%s", result.inserted_id)
+#                 except Exception as verify_err:
+#                     log.warning("Could not verify insert: %s", verify_err)
+#             except Exception as mongo_err:
+#                 log.error("Mongo log insert failed: %s, log_doc=%s", mongo_err, log_doc, exc_info=True)
+#         else:
+#             log.warning("MongoDB not configured, skipping log insert")
+
+
+# @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),
+#     appname: 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:
+#         # Handle appname="collage-maker": get category_id from collage-maker if not provided
+#         final_category_id = category_id
+#         if appname == "collage-maker" and not final_category_id:
+#             final_category_id = get_category_id_from_collage_maker()
+#             if final_category_id:
+#                 log.info("Using category_id from collage-maker: %s", final_category_id)
+        
+#         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"))
+#             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": "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 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, final_category_id, appname)
+#         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,
+#         }
+#         # Store appname in api_logs if provided
+#         if appname:
+#             log_doc["appname"] = appname
+#         if error_msg:
+#             log_doc["error"] = error_msg
+#         if mongo_logs is not None:
+#             try:
+#                 log.info("Inserting log to MongoDB - Database: %s, Collection: %s", mongo_logs.database.name, mongo_logs.name)
+#                 result = mongo_logs.insert_one(log_doc)
+#                 log.info("Mongo log inserted successfully: _id=%s, output_id=%s, status=%s, db=%s, collection=%s", 
+#                         result.inserted_id, output_name, status, mongo_logs.database.name, mongo_logs.name)
+                
+#                 # Verify the insert by reading it back
+#                 try:
+#                     verify_doc = mongo_logs.find_one({"_id": result.inserted_id})
+#                     if verify_doc:
+#                         log.info("Verified: Document exists in MongoDB after insert")
+#                     else:
+#                         log.error("WARNING: Document not found after insert! _id=%s", result.inserted_id)
+#                 except Exception as verify_err:
+#                     log.warning("Could not verify insert: %s", verify_err)
+#             except Exception as mongo_err:
+#                 log.error("Mongo log insert failed: %s, log_doc=%s", mongo_err, log_doc, exc_info=True)
+#         else:
+#             log.warning("MongoDB not configured, skipping log insert")
+
+
+# @app.get("/download/{filename}")
+# def download_file(filename: str):
+#     path = os.path.join(OUTPUT_DIR, filename)
+#     if not os.path.isfile(path):
+#         raise HTTPException(status_code=404, detail="file not found")
+#     return FileResponse(path)
+
+
+# @app.get("/result/{filename}")
+# def view_result(filename: str):
+#     """View result image directly in browser (same as download but with proper content-type for viewing)"""
+#     path = os.path.join(OUTPUT_DIR, filename)
+#     if not os.path.isfile(path):
+#         raise HTTPException(status_code=404, detail="file not found")
+#     return FileResponse(path, media_type="image/png")
+
+
+# @app.get("/logs")
+# def get_logs(_: None = Depends(bearer_auth)) -> JSONResponse:
+#     return JSONResponse(content=logs)