api/main.py

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
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
import boto3
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)

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")

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
spaces_client = None
spaces_enabled = False
spaces_counter_lock = threading.Lock()
spaces_pair_counter: Optional[int] = 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.")

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"
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 _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,
) -> 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
    spaces_info = 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)

        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')}"
        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
        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)
        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 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)
        #         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
    spaces_info = 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)
        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)
        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)
        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 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)
                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
    spaces_info = 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)
            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:
                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
            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

        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)
                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
            # 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)
        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:
            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
        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:
        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 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)
                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
    spaces_info = 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)
            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
        # 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)
        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:
            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
        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:
        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 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)
                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)

# 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)