memecoin_routes.py

"""
Memecoin Routes for File-Based Operations

FastAPI routes for memecoin CRUD operations that integrate with the
MemeStorageOrchestrator to provide API-first access to filesystem-based
memecoin data without direct file mounts.
"""

import logging
import time
from datetime import datetime
from typing import Any, Dict, List, Optional, Tuple

from fastapi import APIRouter, Depends, HTTPException, Query, Response
from pydantic import BaseModel, Field

from src.orchestrators.meme_storage import MemeStorageOrchestrator
from src.util.error_sanitizer import sanitize_error_message
from src.web_ui.api_models.base import APIResponse
from src.web_ui.api_models.memecoin import (
    GeneratedMemecoinDetailResponse,
    GeneratedMemecoinListResponse,
    MemecoinDatabaseStats,
    MemecoinDetailResponse,
    MemecoinListResponse,
    MemecoinResponse,
    MemecoinStatsData,
    MemecoinStatsItem,
    MemecoinStatsResponse,
    MemecoinUpdateRequest,
    MemecoinUpdateResponse,
)
from src.web_ui.dependencies import get_meme_storage_orchestrator, get_generation_orchestrator

# Configure logging with explicit level
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

# Add handler if no handlers exist (uvicorn compatibility)
if not logger.handlers:
    handler = logging.StreamHandler()
    handler.setLevel(logging.INFO)
    formatter = logging.Formatter('%(levelname)s:     %(name)s - %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)

# Test log to verify logging works
logger.info("🔧 Memecoin routes module loaded - logging is active")

# Create router
router = APIRouter(prefix="/api/memecoins", tags=["memecoin_operations"])

# Stats cache: (stats_data, timestamp)
_stats_cache: Optional[Tuple[MemecoinStatsData, float]] = None
STATS_CACHE_TIMEOUT = 30  # seconds


# ================================================================================
# PYDANTIC MODELS FOR GENERATED MEMECOIN EDITING
# ================================================================================


class GeneratedEditFeedbackRequest(BaseModel):
    """Request model for generated memecoin edit feedback with optional current metadata

    Supports two workflows:
    1. User provides only AI feedback → Uses stored metadata as baseline
    2. User edits fields + provides AI feedback → Uses current_metadata as baseline
    """

    feedback: str = Field(
        ...,
        min_length=1,
        max_length=2000,
        description="User feedback about what to edit"
    )

    current_metadata: Optional[Dict[str, Any]] = Field(
        default=None,
        description="Current token metadata from UI (name, ticker, description, tags). "
                    "If provided, used as baseline for AI edits. If None, loads from storage."
    )


class GeneratedEditProposalResponse(BaseModel):
    """Response model for generated memecoin edit proposal generation"""

    status: int = Field(default=200, description="HTTP status code")
    success: bool = Field(..., description="Whether operation succeeded")
    message: str = Field(..., description="Human-readable message")
    proposal_uuid: Optional[str] = Field(
        None, description="UUID for the cached proposal"
    )
    proposal: Optional[Dict] = Field(None, description="The edit proposal data")


class GeneratedAcceptProposalRequest(BaseModel):
    """Request model for accepting a generated memecoin edit proposal"""

    proposal_uuid: str = Field(
        ..., min_length=1, description="UUID of the cached proposal"
    )
    edited_proposal: Optional[Dict] = Field(
        None,
        description="Optional manually edited proposal (overrides cached version)"
    )


class GeneratedAcceptProposalResponse(BaseModel):
    """Response model for accepting a generated memecoin edit proposal"""

    status: int = Field(default=200, description="HTTP status code")
    success: bool = Field(..., description="Whether operation succeeded")
    message: str = Field(..., description="Human-readable message")


@router.get(
    "/stats",
    response_model=MemecoinStatsResponse,
    summary="Get memecoin knowledge base statistics",
    description="""Get aggregated statistics for the entire memecoin knowledge base.

    **Statistics Included:**
    - Pending memecoins count (from filesystem)
    - Approved memecoins count (from filesystem)
    - Vector database count (from ChromaDB)
    - Total count across all categories

    **Caching:**
    - Stats are cached for 30 seconds for optimal performance
    - Automatic refresh on cache expiration

    **Use Cases:**
    - Dashboard statistics display
    - Homepage stats summary
    - System health monitoring
    - Data completeness validation
    """,
    response_description="Aggregated memecoin statistics with counts and timestamps",
)
async def get_memecoin_stats(
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> MemecoinStatsResponse:
    """
    Get aggregated statistics for memecoin knowledge base

    Aggregates counts from:
    - Pending directory (filesystem via orchestrator)
    - Approved directory (filesystem via orchestrator)
    - Vector database (ChromaDB via database interface)

    Returns:
        MemecoinStatsResponse with counts and timestamps
    """
    global _stats_cache

    try:
        # Check cache validity
        current_time = time.time()
        if _stats_cache is not None:
            cached_data, cache_timestamp = _stats_cache
            if current_time - cache_timestamp < STATS_CACHE_TIMEOUT:
                logger.info(
                    f"📊 Returning cached stats (age: {current_time - cache_timestamp:.1f}s)"
                )
                return MemecoinStatsResponse(
                    status=200,
                    success=True,
                    message="Stats retrieved from cache",
                    stats=cached_data,
                )

        logger.info("📊 Fetching fresh memecoin stats...")

        # Get pending count from orchestrator
        pending_result = await orchestrator.get_pending_memecoins(page=1, limit=1)
        pending_count = pending_result.total
        pending_timestamp = datetime.utcnow().isoformat() + "Z"

        logger.info(f"  • Pending: {pending_count}")

        # Get approved count from orchestrator
        approved_result = await orchestrator.get_approved_memecoins(page=1, limit=1)
        approved_count = approved_result.total
        approved_timestamp = datetime.utcnow().isoformat() + "Z"

        logger.info(f"  • Approved: {approved_count}")

        # Get database stats from orchestrator
        db_stats = await orchestrator.get_database_stats()
        logger.debug(f"Raw db_stats from vector store: {db_stats}")
        db_count = db_stats.get("total_examples", 0)
        # Database interface may provide separate counts for text/image embeddings
        db_text_count = db_stats.get("text_embeddings", db_count)
        db_image_count = db_stats.get("image_embeddings", db_count)
        db_timestamp = datetime.utcnow().isoformat() + "Z"

        logger.info(
            f"  • Database: {db_count} (text: {db_text_count}, images: {db_image_count})"
        )

        # Calculate total
        total_count = pending_count + approved_count + db_count

        # Build response
        stats_data = MemecoinStatsData(
            pending=MemecoinStatsItem(
                count=pending_count, last_updated=pending_timestamp
            ),
            approved=MemecoinStatsItem(
                count=approved_count, last_updated=approved_timestamp
            ),
            database=MemecoinDatabaseStats(
                count=db_count,
                text_embeddings=db_text_count,
                image_embeddings=db_image_count,
                last_updated=db_timestamp,
            ),
            total=total_count,
        )

        # Update cache
        _stats_cache = (stats_data, current_time)
        logger.info(f"✅ Stats cached: Total {total_count} memecoins")

        return MemecoinStatsResponse(
            status=200,
            success=True,
            message="Stats retrieved successfully",
            stats=stats_data,
        )

    except Exception as e:
        logger.error(f"❌ Error getting memecoin stats: {e}")
        sanitized_error = sanitize_error_message(e)
        raise HTTPException(status_code=500, detail=sanitized_error)


@router.get("/pending", response_model=MemecoinListResponse)
async def get_pending_memecoins(
    response: Response,
    page: int = Query(1, ge=1, description="Page number (1-based)"),
    limit: int = Query(
        100, ge=1, le=500, description="Number of memecoins per page (max 500)"
    ),
    search: Optional[str] = Query(
        None, description="Search query for tags, name, ticker, or description"
    ),
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> MemecoinListResponse:
    """
    Get paginated list of pending memecoins from filesystem

    Args:
        page: Page number (1-based)
        limit: Number of memecoins per page (max 500)
        search: Search query for filtering

    Returns:
        MemecoinListResponse with pending memecoins (Base64 images)
    """
    try:
        logger.info(
            f"📄 Getting pending memecoins (page={page}, limit={limit}, search={search})"
        )

        result = await orchestrator.get_pending_memecoins(
            page=page, limit=limit, search=search
        )

        logger.info(
            f"✅ Retrieved {len(result.memecoins)} pending memecoins from filesystem"
        )

        # Set cache-control headers
        response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
        response.headers["Pragma"] = "no-cache"
        response.headers["Expires"] = "0"

        return result

    except Exception as e:
        logger.error(f"❌ Error getting pending memecoins: {e}")
        sanitized_error = sanitize_error_message(e)
        raise HTTPException(status_code=500, detail=sanitized_error)


@router.get("/approved", response_model=MemecoinListResponse)
async def get_approved_memecoins(
    response: Response,
    page: int = Query(1, ge=1, description="Page number (1-based)"),
    limit: int = Query(
        100, ge=1, le=500, description="Number of memecoins per page (max 500)"
    ),
    search: Optional[str] = Query(
        None, description="Search query for tags, name, ticker, or description"
    ),
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> MemecoinListResponse:
    """
    Get paginated list of approved memecoins from filesystem

    Args:
        page: Page number (1-based)
        limit: Number of memecoins per page (max 500)
        search: Search query for filtering

    Returns:
        MemecoinListResponse with approved memecoins (Base64 images)
    """
    try:
        logger.info(
            f"📄 Getting approved memecoins (page={page}, limit={limit}, search={search})"
        )

        result = await orchestrator.get_approved_memecoins(
            page=page, limit=limit, search=search
        )

        logger.info(
            f"✅ Retrieved {len(result.memecoins)} approved memecoins from filesystem"
        )

        # Set cache-control headers
        response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
        response.headers["Pragma"] = "no-cache"
        response.headers["Expires"] = "0"

        return result

    except Exception as e:
        logger.error(f"❌ Error getting approved memecoins: {e}")
        sanitized_error = sanitize_error_message(e)
        raise HTTPException(status_code=500, detail=sanitized_error)


@router.post("/approve/{token_address}", response_model=APIResponse)
async def approve_memecoin(
    token_address: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> APIResponse:
    """
    Approve a pending memecoin (move from pending to approved directory)

    Args:
        token_address: Token address of memecoin to approve

    Returns:
        APIResponse with operation results
    """
    try:
        logger.info(f"✅ Approving memecoin: {token_address}")

        success, message, memecoin_data = await orchestrator.approve_memecoin(
            token_address
        )

        if success:
            logger.info(f"✅ Successfully approved memecoin: {token_address}")
            return APIResponse(status=200, success=True, message=message)
        else:
            logger.error(f"❌ Failed to approve memecoin: {token_address} - {message}")
            return APIResponse(
                status=400, success=False, message=message, error=message
            )

    except Exception as e:
        logger.error(f"❌ Error approving memecoin {token_address}: {e}")
        sanitized_error = sanitize_error_message(e)
        raise HTTPException(status_code=500, detail=sanitized_error)


@router.delete("/pending/{token_address}", response_model=APIResponse)
async def delete_pending_memecoin(
    token_address: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> APIResponse:
    """
    Delete a pending memecoin permanently

    Args:
        token_address: Token address of memecoin to delete

    Returns:
        APIResponse confirming deletion
    """
    try:
        logger.info(f"🗑️ Deleting pending memecoin: {token_address}")

        success, message, memecoin_data = await orchestrator.delete_memecoin(
            token_address, source="pending"
        )

        if success:
            logger.info(f"✅ Successfully deleted pending memecoin: {token_address}")
            return APIResponse(status=200, success=True, message=message)
        else:
            logger.error(
                f"❌ Failed to delete pending memecoin: {token_address} - {message}"
            )
            return APIResponse(
                status=400, success=False, message=message, error=message
            )

    except Exception as e:
        logger.error(f"❌ Error deleting pending memecoin {token_address}: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to delete pending memecoin: {e}"
        )


@router.delete("/approved/{token_address}", response_model=APIResponse)
async def delete_approved_memecoin(
    token_address: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> APIResponse:
    """
    Delete an approved memecoin permanently

    Args:
        token_address: Token address of memecoin to delete

    Returns:
        APIResponse confirming deletion
    """
    try:
        logger.info(f"🗑️ Deleting approved memecoin: {token_address}")

        success, message, memecoin_data = await orchestrator.delete_memecoin(
            token_address, source="approved"
        )

        if success:
            logger.info(f"✅ Successfully deleted approved memecoin: {token_address}")
            return APIResponse(status=200, success=True, message=message)
        else:
            logger.error(
                f"❌ Failed to delete approved memecoin: {token_address} - {message}"
            )
            return APIResponse(
                status=400, success=False, message=message, error=message
            )

    except Exception as e:
        logger.error(f"❌ Error deleting approved memecoin {token_address}: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to delete approved memecoin: {e}"
        )


@router.delete("/database/{token_address}", response_model=APIResponse)
async def delete_database_memecoin(
    token_address: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> APIResponse:
    """
    Delete a memecoin from the vector database permanently

    This deletes from ChromaDB collections (text + image embeddings),
    associated image files, and caption files.

    Args:
        token_address: Token address of memecoin to delete
        orchestrator: MemeStorageOrchestrator for database operations

    Returns:
        APIResponse confirming deletion
    """
    try:
        logger.info(f"🗑️ Deleting memecoin from vector database: {token_address}")

        success = await orchestrator.delete_database_memecoin(token_address)

        if success:
            logger.info(
                f"✅ Successfully deleted memecoin from vector database: {token_address}"
            )
            return APIResponse(
                status=200,
                success=True,
                message=f"Memecoin {token_address} deleted from vector database",
            )
        else:
            logger.warning(f"⚠️ Memecoin not found in vector database: {token_address}")
            return APIResponse(
                status=404,
                success=False,
                message=f"Memecoin {token_address} not found in vector database",
            )

    except Exception as e:
        logger.error(
            f"❌ Error deleting memecoin from vector database {token_address}: {e}"
        )
        raise HTTPException(
            status_code=500,
            detail=f"Failed to delete memecoin from vector database: {e}",
        )


@router.post("/degrade/{token_address}", response_model=APIResponse)
async def degrade_database_memecoin(
    token_address: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> APIResponse:
    """
    Degrade a memecoin from vector database back to approved collection

    This operation:
    1. Deletes memecoin from all 5 ChromaDB collections
    2. Deletes associated image and caption files from rag_db
    3. Moves metadata JSON to approved collection (strips caption field)
    4. Moves image JPG to approved collection
    5. Invalidates stats cache

    Use case: Fix incorrect tags/captions and reprocess through workflow

    Args:
        token_address: Token address of memecoin to degrade
        orchestrator: MemeStorageOrchestrator for database and file operations

    Returns:
        APIResponse with operation results
    """
    try:
        logger.info(
            f"⬇️ Degrading memecoin from vector database to approved: {token_address}"
        )

        success, message = await orchestrator.degrade_database_memecoin(token_address)

        if success:
            logger.info(f"✅ Successfully degraded memecoin: {token_address}")
            return APIResponse(status=200, success=True, message=message)
        else:
            logger.warning(f"⚠️ Failed to degrade memecoin: {token_address} - {message}")
            return APIResponse(
                status=400, success=False, message=message, error=message
            )

    except Exception as e:
        logger.error(f"❌ Error degrading memecoin {token_address}: {e}")
        sanitized_error = sanitize_error_message(e)
        raise HTTPException(
            status_code=500, detail=f"Failed to degrade memecoin: {sanitized_error}"
        )


@router.get("/pending/{token_address}", response_model=MemecoinDetailResponse)
async def get_pending_memecoin(
    token_address: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> MemecoinDetailResponse:
    """
    Get a specific pending memecoin by token address

    Args:
        token_address: Token address to search for

    Returns:
        MemecoinDetailResponse with memecoin data and Base64 image
    """
    try:
        logger.info(f"📄 Getting pending memecoin: {token_address}")

        result = await orchestrator.get_pending_memecoin(token_address)

        if result["found"]:
            logger.info(f"✅ Found pending memecoin: {token_address}")
            return MemecoinDetailResponse(
                status=200,
                success=True,
                message="Pending memecoin retrieved successfully",
                memecoin=result["memecoin"],
            )
        else:
            logger.warning(f"❌ Pending memecoin not found: {token_address}")
            raise HTTPException(
                status_code=404, detail=f"Pending memecoin '{token_address}' not found"
            )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Error getting pending memecoin {token_address}: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to retrieve pending memecoin: {e}"
        )


@router.get("/approved/{token_address}", response_model=MemecoinDetailResponse)
async def get_approved_memecoin(
    token_address: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> MemecoinDetailResponse:
    """
    Get a specific approved memecoin by token address

    Args:
        token_address: Token address to search for

    Returns:
        MemecoinDetailResponse with memecoin data and Base64 image
    """
    try:
        logger.info(f"📄 Getting approved memecoin: {token_address}")

        result = await orchestrator.get_approved_memecoin(token_address)

        if result["found"]:
            logger.info(f"✅ Found approved memecoin: {token_address}")
            return MemecoinDetailResponse(
                status=200,
                success=True,
                message="Approved memecoin retrieved successfully",
                memecoin=result["memecoin"],
            )
        else:
            logger.warning(f"❌ Approved memecoin not found: {token_address}")
            raise HTTPException(
                status_code=404, detail=f"Approved memecoin '{token_address}' not found"
            )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Error getting approved memecoin {token_address}: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to retrieve approved memecoin: {e}"
        )


@router.get("/image/{token_address}")
async def get_memecoin_image(
    token_address: str,
    source: str = Query(
        "approved", description="Source directory: 'pending', 'approved', or 'database'"
    ),
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> Response:
    """
    Get memecoin image as direct binary response

    Args:
        token_address: Token address to search for
        source: Source directory ('pending', 'approved', or 'database')
                'database' loads from vector DB images (res/memecoins/rag_db/images/)

    Returns:
        Image binary data with proper Content-Type
    """
    try:
        logger.info(f"🖼️ Image API request: token={token_address}, source={source}")

        result = await orchestrator.get_memecoin_image(token_address, source=source)

        if result["found"]:
            logger.info(f"✅ Image found: {token_address} from {source} ({len(result['image_data'])} bytes)")

            # Return binary image with proper content type
            return Response(
                content=result["image_data"],
                media_type=result["content_type"],
                headers={
                    "Cache-Control": "no-cache, no-store, must-revalidate",  # Prevent caching
                    "Pragma": "no-cache",
                    "Expires": "0",
                    "Content-Disposition": f'inline; filename="{token_address}.jpg"',
                },
            )
        else:
            logger.warning(f"❌ Image not found: {token_address} in {source}")
            raise HTTPException(
                status_code=404,
                detail=f"Image for memecoin '{token_address}' not found in {source}",
            )

    except HTTPException:
        raise
    except Exception as e:
        import traceback
        logger.error(f"❌ Error loading image {token_address} from {source}: {e}")
        logger.error(f"Stack trace: {traceback.format_exc()}")
        raise HTTPException(
            status_code=500, detail=f"Failed to retrieve memecoin image: {e}"
        )


@router.post("/refresh-cache", response_model=APIResponse)
async def refresh_memecoin_cache(
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> APIResponse:
    """
    Force refresh of all cached memecoin data

    Returns:
        APIResponse confirming cache refresh
    """
    try:
        logger.info("🔄 Refreshing memecoin cache...")

        await orchestrator.refresh_cache()

        logger.info("✅ Memecoin cache refreshed successfully")

        return APIResponse(
            status=200, success=True, message="Memecoin cache refreshed successfully"
        )

    except Exception as e:
        logger.error(f"❌ Error refreshing memecoin cache: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to refresh memecoin cache: {e}"
        )


# Generated Memecoins API Endpoints


@router.get("/generated", response_model=GeneratedMemecoinListResponse)
async def list_generated_memecoins(
    page: int = Query(1, ge=1, description="Page number (1-based)"),
    limit: int = Query(20, ge=1, le=100, description="Items per page"),
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> GeneratedMemecoinListResponse:
    """
    List generated memecoins with pagination

    Args:
        page: Page number (1-based)
        limit: Items per page (max 100)
        orchestrator: MemeStorageOrchestrator for storage operations

    Returns:
        Paginated list of generated memecoins
    """
    try:
        logger.info(f"📋 Listing generated memecoins: page={page}, limit={limit}")

        # Get paginated list from orchestrator
        result = await orchestrator.list_generated_memecoins(page=page, limit=limit)

        # Convert to response format
        memecoins_data = []
        for memecoin in result.memecoins:
            # Only include fields needed by frontend
            # Exclude: token_address (not launched), image_caption (unused),
            #          tags/tags_categories (removed from generated memes), generation_info (internal metadata)
            memecoin_data = {
                "uuid": memecoin.uuid,
                "token_name": memecoin.name,
                "ticker": memecoin.ticker,
                "description": memecoin.description,
                "image_data": memecoin.image_data,
                "creation_date": memecoin.created_at,  # ISO timestamp for display
                "has_image": bool(memecoin.image_data),
            }
            memecoins_data.append(memecoin_data)

        logger.info(f"✅ Listed {len(memecoins_data)} generated memecoins")

        return GeneratedMemecoinListResponse(
            status=200,
            success=True,
            message="Generated memecoins retrieved successfully",
            memecoins=memecoins_data,
            total=result.total,
            page=result.page,
            limit=result.limit,
            total_pages=result.total_pages,
            has_next=result.has_next,
            has_prev=result.has_prev,
        )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Error listing generated memecoins: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to list generated memecoins: {e}"
        )


@router.get("/generated/{uuid}", response_model=GeneratedMemecoinDetailResponse)
async def get_generated_memecoin(
    uuid: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> GeneratedMemecoinDetailResponse:
    """
    Get a specific generated memecoin by UUID

    Args:
        uuid: UUID of the generated memecoin
        orchestrator: MemeStorageOrchestrator for storage operations

    Returns:
        Generated memecoin data
    """
    try:
        logger.info(f"🔍 Getting generated memecoin: {uuid[:8]}")

        # Load memecoin from orchestrator
        memecoin = await orchestrator.get_generated_memecoin(uuid)
        if not memecoin:
            logger.warning(f"❌ Generated memecoin not found: {uuid[:8]}")
            raise HTTPException(
                status_code=404,
                detail=f"Generated memecoin '{uuid}' not found",
            )

        # Convert to response format
        memecoin_data = {
            "uuid": memecoin.uuid,
            "token_name": memecoin.name,
            "ticker": memecoin.ticker,
            "token_address": "",
            "description": memecoin.description,
            "image_data": memecoin.image_data,
            "creation_date": memecoin.created_at,
            "has_image": bool(memecoin.image_data),
            "image_caption": "",
            "generation_info": memecoin.generation_info,
        }

        logger.info(f"✅ Found generated memecoin: {uuid[:8]}")

        return GeneratedMemecoinDetailResponse(
            status=200,
            success=True,
            message="Generated memecoin retrieved successfully",
            memecoin=memecoin_data,
        )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Error getting generated memecoin {uuid[:8]}: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to retrieve generated memecoin: {e}"
        )


@router.put("/generated/{uuid}", response_model=MemecoinUpdateResponse)
async def update_generated_memecoin(
    uuid: str,
    update_data: MemecoinUpdateRequest,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> MemecoinUpdateResponse:
    """
    Update a generated memecoin's metadata

    Args:
        uuid: UUID of the generated memecoin
        update_data: Updated memecoin fields (name, symbol, description, tags)
        orchestrator: MemeStorageOrchestrator for storage operations

    Returns:
        Updated memecoin data
    """
    try:
        logger.info(f"🔍 Updating generated memecoin: {uuid[:8]}")

        # Load existing memecoin from orchestrator
        memecoin = await orchestrator.get_generated_memecoin(uuid)
        if not memecoin:
            logger.warning(f"❌ Generated memecoin not found: {uuid[:8]}")
            raise HTTPException(
                status_code=404,
                detail=f"Generated memecoin '{uuid}' not found",
            )

        # Apply updates (only update fields that were provided)
        if update_data.name is not None:
            memecoin.name = update_data.name
            logger.info(f"  → Updated name: {update_data.name}")

        if update_data.ticker is not None:
            memecoin.ticker = update_data.ticker
            logger.info(f"  → Updated ticker: {update_data.ticker}")

        if update_data.description is not None:
            memecoin.description = update_data.description
            logger.info(
                f"  → Updated description (length: {len(update_data.description)})"
            )

        # Save updated memecoin via orchestrator
        success = await orchestrator.save_generated_memecoin(memecoin)
        if not success:
            logger.error(f"❌ Failed to save updated memecoin {uuid[:8]}")
            raise HTTPException(
                status_code=500,
                detail="Failed to save updated memecoin",
            )

        # Convert to response format
        memecoin_data = {
            "uuid": memecoin.uuid,
            "name": memecoin.name,
            "ticker": memecoin.ticker,
            "description": memecoin.description,
            "tags": memecoin.tags,
            "image_data": memecoin.image_data,
            "created_at": memecoin.created_at,
            "generation_info": memecoin.generation_info,
        }

        logger.info(f"✅ Successfully updated memecoin: {uuid[:8]}")

        return MemecoinUpdateResponse(
            status=200,
            success=True,
            message="Memecoin updated successfully",
            memecoin=memecoin_data,
        )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Error updating generated memecoin {uuid[:8]}: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to update generated memecoin: {e}"
        )


@router.delete("/generated/{uuid}", response_model=APIResponse)
async def delete_generated_memecoin(
    uuid: str,
    orchestrator: MemeStorageOrchestrator = Depends(get_meme_storage_orchestrator),
) -> APIResponse:
    """
    Delete a generated memecoin

    Args:
        uuid: UUID of the memecoin to delete
        orchestrator: MemeStorageOrchestrator for storage operations

    Returns:
        Success confirmation
    """
    try:
        logger.info(f"🗑️ Deleting generated memecoin: {uuid[:8]}")

        # Delete memecoin via orchestrator
        success = await orchestrator.delete_generated_memecoin(uuid)
        if not success:
            logger.warning(f"❌ Generated memecoin not found for deletion: {uuid[:8]}")
            raise HTTPException(
                status_code=404,
                detail=f"Generated memecoin '{uuid}' not found",
            )

        logger.info(f"✅ Deleted generated memecoin: {uuid[:8]}")

        return APIResponse(
            status=200,
            success=True,
            message=f"Generated memecoin '{uuid}' deleted successfully",
        )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Error deleting generated memecoin {uuid[:8]}: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to delete generated memecoin: {e}"
        )


# ================================================================================
# GENERATED MEMECOIN EDITING ENDPOINTS
# ================================================================================


@router.post(
    "/generated/{uuid}/ai-edit",
    response_model=GeneratedEditProposalResponse,
    summary="Generate edit proposal for generated memecoin",
    description="""Generate an AI-powered edit proposal based on user feedback.

    **Flow:**
    1. User provides feedback about what to change
    2. AI analyzes feedback and determines affected parts
    3. Retrieves context from vector DB if needed (for logos, entities)
    4. Regenerates affected metadata and/or image
    5. Returns proposal with UUID for review
    6. Proposal cached for 5 minutes

    **Intelligent Features:**
    - Automatic decision of what needs regeneration
    - Context retrieval for accurate entity representation
    - Conditional image regeneration with visual references
    - Targeted metadata updates (only affected fields)

    **Feedback Examples:**
    - "Make the dog blue instead of brown"
    - "Fix the BNB logo - it should be the official one"
    - "Change name to something with wordplay"
    - "Wrong art style - should be pixel art"
    """,
)
async def generate_generated_edit_proposal(
    uuid: str,
    request: GeneratedEditFeedbackRequest,
    generation_orchestrator=Depends(get_generation_orchestrator),
) -> GeneratedEditProposalResponse:
    """
    Generate edit proposal for generated memecoin

    Args:
        uuid: UUID of generated memecoin to edit
        request: User feedback request (feedback + optional current_metadata)
        generation_orchestrator: GenerationOrchestrator for edit operations

    Returns:
        Edit proposal with UUID for review
    """
    try:
        logger.info(f"🔧 Edit proposal request for generated memecoin: {uuid[:8]}")

        # Log if current metadata was provided (helps debugging)
        if request.current_metadata:
            logger.info("📝 Request includes current metadata from UI")

        success, message, result = await generation_orchestrator.generate_generated_edit_proposal(
            uuid=uuid,
            user_feedback=request.feedback,
            current_metadata=request.current_metadata,
        )

        if not success:
            raise HTTPException(status_code=400, detail=message)

        logger.info(f"✅ Edit proposal generated: {result['proposal_uuid'][:8]}")

        return GeneratedEditProposalResponse(
            status=200,
            success=True,
            message=message,
            proposal_uuid=result["proposal_uuid"],
            proposal=result["proposal"],
        )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Error generating edit proposal: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to generate edit proposal: {e}"
        )


@router.patch(
    "/generated/{uuid}",
    response_model=GeneratedAcceptProposalResponse,
    summary="Accept and apply edit proposal",
    description="""Accept an edit proposal and atomically update the generated memecoin.

    **Flow:**
    1. Retrieves proposal from cache (or uses provided edited_proposal)
    2. Validates proposal hasn't expired (5 minute TTL)
    3. Applies all changes in-place (same UUID)
    4. Saves to storage
    5. Removes proposal from cache

    **What Gets Updated:**
    - Token name (if changed)
    - Ticker (if changed)
    - Description (if changed)
    - Image (if regenerated)

    **Optional Manual Editing:**
    - You can provide edited_proposal to override cached version
    - Useful for fine-tuning the AI-generated proposal
    """,
)
async def accept_generated_edit_proposal(
    uuid: str,
    request: GeneratedAcceptProposalRequest,
    generation_orchestrator=Depends(get_generation_orchestrator),
) -> GeneratedAcceptProposalResponse:
    """
    Accept and apply edit proposal to generated memecoin

    Args:
        uuid: UUID of generated memecoin to update
        request: Accept proposal request with UUID
        generation_orchestrator: GenerationOrchestrator for update operations

    Returns:
        Success confirmation
    """
    try:
        logger.info(f"📥 Accept proposal request for {uuid[:8]}: {request.proposal_uuid[:8]}")

        success, message = await generation_orchestrator.accept_generated_edit_proposal(
            proposal_uuid=request.proposal_uuid,
            uuid=uuid,
            edited_proposal=request.edited_proposal,
        )

        if not success:
            raise HTTPException(status_code=400, detail=message)

        logger.info(f"✅ Edit proposal accepted and applied: {uuid[:8]}")

        return GeneratedAcceptProposalResponse(
            status=200,
            success=True,
            message=message,
        )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Error accepting edit proposal: {e}")
        raise HTTPException(
            status_code=500, detail=f"Failed to accept edit proposal: {e}"
        )