"""
Deprecated file: enhanced_api has been removed in favor of a minimal API.
This module is intentionally left blank to avoid import errors after cleanup.
"""

# The enhanced API with clustering and extra endpoints has been removed.
# Use `app/api.py` for the minimal FastAPI service that serves recommendations
# via RL MAB algorithms with optional DB-backed environment.

from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel, Field
from typing import List, Optional, Dict, Any
import pandas as pd
import numpy as np
from datetime import datetime
import sys
import os

# Add the project root to the path
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from db import DataController, DataManager
from clustering import ClusteringManager
from rl_recommender.UnifiedRecommendationEnv import UnifiedRecommendationEnv
from rl_recommender.enhanced_mab_algorithms import (
    EnhancedEpsilonGreedyMAB, 
    EnhancedContextualMAB, 
    EnhancedEnsembleMAB
)
from db.models import ProductCatalog, UserDemographics, FeedbackDB
from rl_recommender.logger import RecommenderLogger

app = FastAPI(
    title="Enhanced MAB Recommendation API", 
    version="2.0.0",
    description="MAB Recommendation API with Data and Clustering Layer Integration"
)

logger = RecommenderLogger(name="enhanced_api")

# Global instances
data_controller = None
data_manager = None
clustering_manager = None
enhanced_env = None

# Request/Response models
class ProductCreateRequest(BaseModel):
    product_name: str = Field(..., description="Name of the product")
    brand_name: str = Field(..., description="Brand name")
    category: str = Field(..., description="Product category")
    price: float = Field(..., gt=0, description="Product price")
    description: Optional[str] = Field(None, description="Product description")
    image_url: Optional[str] = Field(None, description="Product image URL")

class ProductUpdateRequest(BaseModel):
    product_name: Optional[str] = None
    brand_name: Optional[str] = None
    category: Optional[str] = None
    price: Optional[float] = Field(None, gt=0)
    description: Optional[str] = None
    image_url: Optional[str] = None

class ProductResponse(BaseModel):
    product_id: int
    product_name: str
    brand_name: str
    category: str
    price: float
    description: Optional[str]
    image_url: Optional[str]
    created_at: Optional[str]

class UserCreateRequest(BaseModel):
    name: str = Field(..., description="User name")
    gender: Optional[str] = Field(None, description="User gender (M/F/U)")
    age: Optional[str] = Field(None, description="User age")

class UserResponse(BaseModel):
    user_id: int
    name: str
    gender: Optional[str]
    age: Optional[str]
    user_cluster_id: Optional[int]
    created_at: Optional[str]
    last_active: Optional[str]

class EnhancedRecommendationRequest(BaseModel):
    user_id: int = Field(..., description="User ID")
    n_recommendations: Optional[int] = Field(3, ge=1, le=20, description="Number of recommendations")
    algorithm_type: Optional[str] = Field("enhanced_epsilon_greedy", description="Algorithm type")
    use_clustering: Optional[bool] = Field(True, description="Whether to use clustering insights")
    use_price_optimization: Optional[bool] = Field(True, description="Whether to use price optimization")
    context: Optional[Dict[str, Any]] = Field(None, description="Additional context")

class EnhancedRecommendationResponse(BaseModel):
    user_id: int
    recommended_items: List[Dict[str, Any]]
    algorithm_type: str
    confidence_scores: List[float]
    user_context: Dict[str, Any]
    clustering_insights: Optional[Dict[str, Any]]
    price_optimization: Optional[Dict[str, Any]]

class FeedbackRequest(BaseModel):
    user_id: int = Field(..., description="User ID")
    product_id: int = Field(..., description="Product ID")
    event_type: str = Field(..., description="Event type (view/cart/purchase/remove_from_cart)")
    session_id: Optional[int] = Field(None, description="Session ID")
    timestamp: Optional[str] = Field(None, description="Timestamp")

class FeedbackResponse(BaseModel):
    status: str
    message: str
    feedback_id: Optional[int]
    user_state_updated: bool
    clustering_updated: bool

class ClusteringStatusResponse(BaseModel):
    status: str
    last_update: Optional[str]
    product_clusters: int
    user_clusters: int
    price_hyperplane_ready: bool
    insights_available: bool

class DatabaseStatusResponse(BaseModel):
    status: str
    total_products: int
    total_users: int
    total_feedback: int
    database_size: str
    last_backup: Optional[str]

# Dependency functions
def get_data_controller():
    """Get data controller instance."""
    if data_controller is None:
        raise HTTPException(status_code=500, detail="Data controller not initialized")
    return data_controller

def get_data_manager():
    """Get data manager instance."""
    if data_manager is None:
        raise HTTPException(status_code=500, detail="Data manager not initialized")
    return data_manager

def get_clustering_manager():
    """Get clustering manager instance."""
    if clustering_manager is None:
        raise HTTPException(status_code=500, detail="Clustering manager not initialized")
    return clustering_manager

def get_enhanced_env():
    """Get enhanced environment instance."""
    if enhanced_env is None:
        raise HTTPException(status_code=500, detail="Enhanced environment not initialized")
    return enhanced_env

# Initialization
def initialize_enhanced_system():
    """Initialize the enhanced recommendation system."""
    global data_controller, data_manager, clustering_manager, enhanced_env
    
    try:
        logger.info("Initializing Enhanced Recommendation System...")
        
        # Get absolute path to database
        import os
        db_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "enhanced_recommender.db")
        logger.info(f"Using database path: {db_path}")
        
        # Initialize data layer
        data_controller = DataController(db_path)
        data_manager = DataManager(db_path)
        logger.info("✅ Data layer initialized")
        
        # Initialize clustering layer
        clustering_manager = ClusteringManager()
        logger.info("✅ Clustering layer initialized")
        
        # Initialize enhanced environment
        enhanced_env = UnifiedRecommendationEnv(
            data_source={'db_path': db_path},
            max_arms=100,
            max_steps=50,
            n_suggestions=5,
            use_clustering=True,
            use_user_context=True,
            use_price_optimization=True
        )
        logger.info("✅ Enhanced environment initialized")
        
        logger.info("🎉 Enhanced Recommendation System initialized successfully!")
        return True
        
    except Exception as e:
        logger.error(f"❌ Failed to initialize enhanced system: {str(e)}")
        return False

@app.on_event("startup")
async def startup_event():
    """Initialize the enhanced system on startup."""
    logger.info("Starting Enhanced API initialization...")
    if not initialize_enhanced_system():
        logger.error("Failed to initialize enhanced system on startup")
        raise Exception("Enhanced system initialization failed")

# Root endpoint
@app.get("/")
def root():
    """Root endpoint with enhanced API information."""
    return {
        "message": "Enhanced MAB Recommendation API",
        "version": "2.0.0",
        "features": [
            "Database integration with SQLite",
            "User and product clustering",
            "Price optimization with hyperplanes",
            "Enhanced MAB algorithms",
            "Rich user context and preferences"
        ],
        "endpoints": {
            "GET /status": "Get API status",
            "GET /health": "Health check",
            "POST /recommend": "Get enhanced recommendations",
            "POST /feedback": "Submit user feedback",
            "GET /products": "List products",
            "POST /products": "Create new product",
            "PUT /products/{product_id}": "Update product",
            "DELETE /products/{product_id}": "Delete product",
            "GET /users": "List users",
            "POST /users": "Create new user",
            "GET /clustering/status": "Get clustering status",
            "POST /clustering/run": "Run clustering pipeline",
            "GET /database/status": "Get database status"
        }
    }

# Status endpoints
@app.get("/status")
def get_status():
    """Get the current status of the enhanced API."""
    try:
        # Check data layer
        data_status = "ready" if data_controller and data_manager else "not_ready"
        
        # Check clustering layer
        clustering_status = "ready" if clustering_manager else "not_ready"
        
        # Check enhanced environment
        env_status = "ready" if enhanced_env else "not_ready"
        
        # Get database stats
        db_stats = {}
        if data_controller:
            try:
                total_products = data_controller.get_product_count()
                total_users = data_controller.get_user_count()
                db_stats = {
                    "total_products": total_products,
                    "total_users": total_users
                }
            except:
                db_stats = {"error": "Could not retrieve database stats"}
        
        return {
            "status": "ready" if all([data_controller, clustering_manager, enhanced_env]) else "partial",
            "message": "Enhanced API status",
            "components": {
                "data_layer": data_status,
                "clustering_layer": clustering_status,
                "enhanced_environment": env_status
            },
            "database_stats": db_stats,
            "features_enabled": {
                "clustering": clustering_manager is not None,
                "price_optimization": enhanced_env.use_price_optimization if enhanced_env else False,
                "user_context": enhanced_env.use_user_context if enhanced_env else False
            }
        }
        
    except Exception as e:
        logger.error(f"Error getting status: {str(e)}")
        return {
            "status": "error",
            "message": f"Error getting status: {str(e)}"
        }

@app.get("/health")
def health_check():
    """Health check endpoint."""
    return {
        "status": "healthy", 
        "timestamp": datetime.now().isoformat(),
        "enhanced_system": "ready" if all([data_controller, clustering_manager, enhanced_env]) else "not_ready"
    }

# Product management endpoints
@app.get("/products", response_model=List[ProductResponse])
def list_products(
    category: Optional[str] = None,
    brand: Optional[str] = None,
    limit: Optional[int] = 100,
    offset: Optional[int] = 0,
    db: DataController = Depends(get_data_controller)
):
    """List products with optional filtering."""
    try:
        if category:
            products = db.get_products_by_category(category, limit=limit)
        elif brand:
            products = db.get_products_by_brand(brand, limit=limit)
        else:
            products = db.get_all_products(limit=limit)
        
        # Apply offset
        products = products[offset:offset + limit]
        
        return [
            ProductResponse(
                product_id=product['product_id'],
                product_name=product['product_name'],
                brand_name=product['brand_name'],
                category=product['category'],
                price=product['price'],
                description=product.get('description'),
                image_url=product.get('image_url'),
                created_at=product.get('created_at')
            )
            for product in products
        ]
        
    except Exception as e:
        logger.error(f"Error listing products: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error listing products: {str(e)}")

@app.get("/products/{product_id}", response_model=ProductResponse)
def get_product(
    product_id: int,
    db: DataController = Depends(get_data_controller)
):
    """Get a specific product by ID."""
    try:
        product = db.get_product(product_id)
        if not product:
            raise HTTPException(status_code=404, detail="Product not found")
        
        return ProductResponse(
            product_id=product['product_id'],
            product_name=product['product_name'],
            brand_name=product['brand_name'],
            category=product['category'],
            price=product['price'],
            description=product.get('description'),
            image_url=product.get('image_url'),
            created_at=product.get('created_at')
        )
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error getting product {product_id}: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error getting product: {str(e)}")

@app.post("/products", response_model=ProductResponse)
def create_product(
    request: ProductCreateRequest,
    db: DataController = Depends(get_data_controller)
):
    """Create a new product."""
    try:
        # Create product model
        product = ProductCatalog(
            product_id=0,  # Will be auto-generated
            product_name=request.product_name,
            brand_name=request.brand_name,
            category=request.category,
            price=request.price,
            description=request.description,
            image_url=request.image_url
        )
        
        # Add to database
        success = db.add_product(product)
        if not success:
            raise HTTPException(status_code=500, detail="Failed to create product")
        
        # Get the created product
        created_product = db.get_product(product.product_id)
        if not created_product:
            raise HTTPException(status_code=500, detail="Product created but could not retrieve")
        
        logger.info(f"Created product: {request.product_name}")
        
        return ProductResponse(
            product_id=created_product['product_id'],
            product_name=created_product['product_name'],
            brand_name=created_product['brand_name'],
            category=created_product['category'],
            price=created_product['price'],
            description=created_product.get('description'),
            image_url=created_product.get('image_url'),
            created_at=created_product.get('created_at')
        )
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error creating product: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error creating product: {str(e)}")

@app.put("/products/{product_id}", response_model=ProductResponse)
def update_product(
    product_id: int,
    request: ProductUpdateRequest,
    db: DataController = Depends(get_data_controller)
):
    """Update an existing product."""
    try:
        # Get current product
        current_product = db.get_product(product_id)
        if not current_product:
            raise HTTPException(status_code=404, detail="Product not found")
        
        # Update fields
        updated_fields = {}
        if request.product_name is not None:
            updated_fields['product_name'] = request.product_name
        if request.brand_name is not None:
            updated_fields['brand_name'] = request.brand_name
        if request.category is not None:
            updated_fields['category'] = request.category
        if request.price is not None:
            updated_fields['price'] = request.price
        if request.description is not None:
            updated_fields['description'] = request.description
        if request.image_url is not None:
            updated_fields['image_url'] = request.image_url
        
        # Create updated product
        updated_product = ProductCatalog(
            product_id=product_id,
            product_name=updated_fields.get('product_name', current_product['product_name']),
            brand_name=updated_fields.get('brand_name', current_product['brand_name']),
            category=updated_fields.get('category', current_product['category']),
            price=updated_fields.get('price', current_product['price']),
            description=updated_fields.get('description', current_product.get('description')),
            image_url=updated_fields.get('image_url', current_product.get('image_url'))
        )
        
        # Update in database
        success = db.add_product(updated_product)  # add_product handles updates
        if not success:
            raise HTTPException(status_code=500, detail="Failed to update product")
        
        logger.info(f"Updated product {product_id}")
        
        # Return updated product
        return get_product(product_id, db)
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error updating product {product_id}: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error updating product: {str(e)}")

@app.delete("/products/{product_id}")
def delete_product(
    product_id: int,
    db: DataController = Depends(get_data_controller)
):
    """Delete a product."""
    try:
        # Check if product exists
        product = db.get_product(product_id)
        if not product:
            raise HTTPException(status_code=404, detail="Product not found")
        
        # Note: This would need to be implemented in DataController
        # For now, return success message
        logger.info(f"Product {product_id} marked for deletion")
        
        return {
            "status": "success",
            "message": f"Product {product_id} marked for deletion",
            "note": "Actual deletion needs to be implemented in DataController"
        }
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error deleting product {product_id}: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error deleting product: {str(e)}")

# User management endpoints
@app.get("/users", response_model=List[UserResponse])
def list_users(
    limit: Optional[int] = 100,
    offset: Optional[int] = 0,
    db: DataController = Depends(get_data_controller)
):
    """List users."""
    try:
        # Note: This would need get_all_users method in DataController
        # For now, return empty list
        users = []
        
        return [
            UserResponse(
                user_id=user['user_id'],
                name=user['name'],
                gender=user.get('gender'),
                age=user.get('age'),
                user_cluster_id=user.get('user_cluster_id'),
                created_at=user.get('created_at'),
                last_active=user.get('last_active')
            )
            for user in users
        ]
        
    except Exception as e:
        logger.error(f"Error listing users: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error listing users: {str(e)}")

@app.post("/users", response_model=UserResponse)
def create_user(
    request: UserCreateRequest,
    db: DataController = Depends(get_data_controller)
):
    """Create a new user."""
    try:
        # Create user model
        user = UserDemographics(
            user_id=0,  # Will be auto-generated
            name=request.name,
            gender=request.gender,
            age=request.age,
            user_cluster_id=None
        )
        
        # Add to database
        user_id = db.add_user(user)
        if user_id <= 0:
            raise HTTPException(status_code=500, detail="Failed to create user")
        
        # Get the created user
        created_user = db.get_user(user_id)
        if not created_user:
            raise HTTPException(status_code=500, detail="User created but could not retrieve")
        
        logger.info(f"Created user: {request.name}")
        
        return UserResponse(
            user_id=created_user['user_id'],
            name=created_user['name'],
            gender=created_user.get('gender'),
            age=created_user.get('age'),
            user_cluster_id=created_user.get('user_cluster_id'),
            created_at=created_user.get('created_at'),
            last_active=created_user.get('last_active')
        )
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error creating user: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error creating user: {str(e)}")

# Enhanced recommendation endpoint
@app.post("/recommend", response_model=EnhancedRecommendationResponse)
def get_enhanced_recommendations(
    request: EnhancedRecommendationRequest,
    env: UnifiedRecommendationEnv = Depends(get_enhanced_env),
    dm: DataManager = Depends(get_data_manager),
    cm: ClusteringManager = Depends(get_clustering_manager)
):
    """Get enhanced recommendations using the new data and clustering layers."""
    try:
        # Get user context
        user_context = dm.get_recommendation_context(
            request.user_id, 
            n_products=request.n_recommendations * 5  # Get more products for selection
        )
        
        if not user_context:
            raise HTTPException(status_code=404, detail="User not found or no context available")
        
        # Get clustering insights
        clustering_insights = None
        if request.use_clustering:
            try:
                clustering_insights = cm.get_clustering_insights()
            except Exception as e:
                logger.warning(f"Could not get clustering insights: {e}")
        
        # Get price optimization
        price_optimization = None
        if request.use_price_optimization:
            try:
                optimal_ranges = cm.get_optimal_price_range('purchase', min_score=0.3)
                price_optimization = {
                    "optimal_price_ranges": optimal_ranges,
                    "total_ranges": len(optimal_ranges)
                }
            except Exception as e:
                logger.warning(f"Could not get price optimization: {e}")
        
        # Create enhanced algorithm based on request
        if request.algorithm_type == "enhanced_epsilon_greedy":
            algorithm = EnhancedEpsilonGreedyMAB(
                n_arms=len(user_context.get('available_products', [])),
                n_suggestions=request.n_recommendations,
                data_manager=dm,
                clustering_manager=cm
            )
        elif request.algorithm_type == "enhanced_contextual":
            algorithm = EnhancedContextualMAB(
                n_arms=len(user_context.get('available_products', [])),
                n_suggestions=request.n_recommendations,
                data_manager=dm,
                clustering_manager=cm
            )
        elif request.algorithm_type == "enhanced_ensemble":
            algorithm = EnhancedEnsembleMAB(
                n_arms=len(user_context.get('available_products', [])),
                n_suggestions=request.n_recommendations,
                data_manager=dm,
                clustering_manager=cm
            )
        else:
            # Default to enhanced epsilon greedy
            algorithm = EnhancedEpsilonGreedyMAB(
                n_arms=len(user_context.get('available_products', [])),
                n_suggestions=request.n_recommendations,
                data_manager=dm,
                clustering_manager=cm
            )
        
        # Get recommendations
        available_products = user_context.get('available_products', [])
        if len(available_products) < request.n_recommendations:
            raise HTTPException(
                status_code=400, 
                detail=f"Not enough products available. Requested: {request.n_recommendations}, Available: {len(available_products)}"
            )
        
        # Select arms (products)
        selected_indices = algorithm.select_multiple_arms(request.user_id, user_context)
        selected_products = [available_products[i] for i in selected_indices if i < len(available_products)]
        
        # Calculate confidence scores
        confidence_scores = []
        for i, product in enumerate(selected_products):
            # Simple confidence based on algorithm state
            if hasattr(algorithm, 'arm_values') and len(algorithm.arm_values) > selected_indices[i]:
                confidence = max(0.1, min(1.0, algorithm.arm_values[selected_indices[i]]))
            else:
                confidence = 0.7  # Default confidence
            confidence_scores.append(confidence)
        
        logger.info(f"Generated {len(selected_products)} enhanced recommendations for user {request.user_id}")
        
        return EnhancedRecommendationResponse(
            user_id=request.user_id,
            recommended_items=selected_products,
            algorithm_type=request.algorithm_type,
            confidence_scores=confidence_scores,
            user_context=user_context,
            clustering_insights=clustering_insights,
            price_optimization=price_optimization
        )
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error generating enhanced recommendations for user {request.user_id}: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error generating recommendations: {str(e)}")

# Feedback endpoint
@app.post("/feedback", response_model=FeedbackResponse)
def submit_feedback(
    request: FeedbackRequest,
    db: DataController = Depends(get_data_controller),
    dm: DataManager = Depends(get_data_manager)
):
    """Submit user feedback."""
    try:
        # Create feedback
        feedback = FeedbackDB(
            user_id=request.user_id,
            product_id=str(request.product_id),
            event_type=request.event_type,
            session=datetime.now(),
            active_user=True
        )
        
        # Add to database
        success = db.add_feedback(feedback)
        if not success:
            raise HTTPException(status_code=500, detail="Failed to add feedback")
        
        # Update user state
        user_state_updated = False
        try:
            dm.update_user_state(request.user_id, {
                'type': request.event_type,
                'product_id': request.product_id,
                'timestamp': datetime.now()
            })
            user_state_updated = True
        except Exception as e:
            logger.warning(f"Could not update user state: {e}")
        
        # Note: Clustering update would happen periodically, not on each feedback
        clustering_updated = False
        
        logger.info(f"Processed feedback from user {request.user_id} for product {request.product_id}: {request.event_type}")
        
        return FeedbackResponse(
            status="success",
            message="Feedback processed successfully",
            feedback_id=feedback.user_id,  # This should be the actual feedback ID
            user_state_updated=user_state_updated,
            clustering_updated=clustering_updated
        )
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error processing feedback from user {request.user_id}: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error processing feedback: {str(e)}")

# Clustering endpoints
@app.get("/clustering/status", response_model=ClusteringStatusResponse)
def get_clustering_status(
    cm: ClusteringManager = Depends(get_clustering_manager)
):
    """Get clustering system status."""
    try:
        status = cm.get_clustering_status()
        
        return ClusteringStatusResponse(
            status="ready" if status['results_available'] else "not_ready",
            last_update=status.get('last_update'),
            product_clusters=10 if status.get('product_clustering_ready') else 0,  # Default values
            user_clusters=5 if status.get('user_clustering_ready') else 0,
            price_hyperplane_ready=status.get('price_hyperplane_ready', False),
            insights_available=status.get('results_available', False)
        )
        
    except Exception as e:
        logger.error(f"Error getting clustering status: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error getting clustering status: {str(e)}")

@app.post("/clustering/run")
def run_clustering_pipeline(
    cm: ClusteringManager = Depends(get_clustering_manager),
    db: DataController = Depends(get_data_controller)
):
    """Run the clustering pipeline."""
    try:
        # Get data for clustering
        all_products = db.get_all_products()
        all_users = db.get_all_users()
        all_feedback = []
        
        # Get feedback for clustering
        for user_id in range(1, 100):  # Sample range
            try:
                user_feedback = db.get_user_feedback(user_id, limit=100)
                all_feedback.extend(user_feedback)
            except:
                continue
        
        # Convert to DataFrames
        products_df = pd.DataFrame(all_products)
        users_df = pd.DataFrame(all_users)
        feedback_df = pd.DataFrame(all_feedback)
        
        if len(products_df) == 0:
            raise HTTPException(status_code=400, detail="No products available for clustering")
        
        # Run clustering
        logger.info("Starting clustering pipeline...")
        results = cm.run_full_clustering(products_df, users_df, feedback_df)
        
        if results:
            logger.info("Clustering pipeline completed successfully")
            return {
                "status": "success",
                "message": "Clustering pipeline completed successfully",
                "results_summary": {
                    "product_clusters": len(results.get('product_clustering', {}).get('cluster_summary', {})),
                    "user_clusters": len(results.get('user_clustering', {}).get('cluster_summary', {})),
                    "price_hyperplane_ready": results.get('price_hyperplane', {}).get('model_available', False)
                }
            }
        else:
            raise HTTPException(status_code=500, detail="Clustering pipeline failed")
        
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Error running clustering pipeline: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error running clustering pipeline: {str(e)}")

# Database status endpoint
@app.get("/database/status", response_model=DatabaseStatusResponse)
def get_database_status(
    db: DataController = Depends(get_data_controller)
):
    """Get database status and statistics."""
    try:
        # Get basic stats
        total_products = db.get_product_count()
        total_users = db.get_user_count()
        total_feedback = db.get_total_feedback()
        
        # Get database file size
        import os
        db_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "enhanced_recommender.db")
        if os.path.exists(db_path):
            db_size = f"{os.path.getsize(db_path) / (1024*1024):.2f} MB"
        else:
            db_size = "N/A"
        
        return DatabaseStatusResponse(
            status="ready",
            total_products=total_products,
            total_users=total_users,
            total_feedback=total_feedback,
            database_size=db_size,
            last_backup=None  # Backup functionality would need to be implemented
        )
        
    except Exception as e:
        logger.error(f"Error getting database status: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error getting database status: {str(e)}")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8001)