from fastapi import APIRouter, HTTPException
import logging
from .apps.products.router import router as products_router
from .apps.inventory.router import router as inventory_router

# Import Celery with error handling for task status endpoint
try:
    from src.utils.celery_worker import celery_app
    celery_available = True
except ImportError as e:
    print(f"Warning: Could not import Celery components: {e}")
    celery_app = None
    celery_available = False

logger = logging.getLogger(__name__)

main_router = APIRouter()

main_router.include_router(
    products_router,
    prefix="/products",
    tags=["Smart Inventory - Products"]
)

main_router.include_router(
    inventory_router,
    prefix="/inventory",
    tags=["Smart Inventory - Inventory"]
)


@main_router.get("/celery/task-status/{task_id}", tags=["Smart Inventory - Common"])
def get_task_status(task_id: str):
    """Get status of a Celery task"""
    if not celery_available:
        raise HTTPException(
            status_code=503, 
            detail="Celery not available. Task status service is currently unavailable."
        )
    
    try:
        if not celery_app:
            raise HTTPException(
                status_code=503, 
                detail="Celery app not available"
            )
        
        task = celery_app.AsyncResult(task_id)
        
        if task.state == 'PENDING':
            # Task is waiting to be processed
            response = {
                'task_id': task_id,
                'status': task.state,
                'message': 'Task is pending...'
            }
        elif task.state == 'PROGRESS':
            # Task is in progress
            response = {
                'task_id': task_id,
                'status': task.state,
                'data': task.result
            }
        elif task.state == 'SUCCESS':
            # Task completed successfully
            response = {
                'task_id': task_id,
                'status': task.state,
                'data': task.result
            }
        else:
            # Task failed or has other status
            response = {
                'task_id': task_id,
                'status': task.state,
                'error': str(task.result) if task.result else 'Unknown error'
            }
        
        return response
        
    except Exception as e:
        logger.error(f"Error getting task status: {str(e)}")
        raise HTTPException(status_code=500, detail="Error getting task status")


# Dependencies for cron-status endpoint
from fastapi import Depends, Query
from sqlalchemy.orm import Session
from sqlalchemy import desc, func
from datetime import datetime, timedelta

try:
    from src.utils.db import get_db
    from src.smart_inventory.jobs.cron_model import CronJobLog
    cron_models_available = True
except ImportError:
    get_db = None
    CronJobLog = None
    cron_models_available = False


@main_router.get("/testing/cron-status", tags=["Smart Inventory - Common"])
def get_cron_status(
    task_type: str = Query(None, description="Filter by task type (e.g., 'daily_sales', 'inventory_snapshot')"),
    days: int = Query(7, ge=1, le=30, description="Number of days to check for recent logs"),
    limit: int = Query(10, ge=1, le=50, description="Number of recent logs to return"),
    db: Session = Depends(get_db)
):
    """
    Get cron job status and recent execution logs for all smart inventory crons.
    Optionally filter by task_type.
    """
    if not cron_models_available:
        raise HTTPException(
            status_code=503,
            detail="Cron models not available"
        )
    
    try:
        now = datetime.utcnow()
        since_date = now - timedelta(days=days)
        
        # Base query - optionally filter by task_type
        base_query = db.query(CronJobLog)
        if task_type:
            base_query = base_query.filter(CronJobLog.task_type == task_type)
        
        # Get recent logs
        recent_logs = base_query\
            .filter(CronJobLog.created_at >= since_date)\
            .order_by(desc(CronJobLog.created_at))\
            .limit(limit)\
            .all()
        
        # Get statistics
        stats_query = db.query(CronJobLog)
        if task_type:
            stats_query = stats_query.filter(CronJobLog.task_type == task_type)
        
        total_executions = stats_query.count()
        successful_executions = stats_query.filter(CronJobLog.status == 'success').count()
        failed_executions = stats_query.filter(CronJobLog.status == 'failed').count()
        
        # Format logs
        formatted_logs = []
        for log in recent_logs:
            formatted_logs.append({
                "id": log.id,
                "task_id": log.task_id,
                "task_type": log.task_type,
                "status": log.status,
                "started_at": log.started_at.isoformat() if log.started_at else None,
                "completed_at": log.completed_at.isoformat() if log.completed_at else None,
                "duration_seconds": log.duration_seconds,
                "error_message": log.error_message,
                "created_at": log.created_at.isoformat() if log.created_at else None
            })
        
        success_rate = (successful_executions / total_executions * 100) if total_executions > 0 else 0
        
        return {
            "statistics": {
                "total_executions": total_executions,
                "successful_executions": successful_executions,
                "failed_executions": failed_executions,
                "success_rate_percent": round(success_rate, 1),
                "days_checked": days
            },
            "recent_logs": formatted_logs,
            "filter": {"task_type": task_type} if task_type else None,
            "metadata": {
                "checked_at": now.isoformat(),
                "available_task_types": ["daily_sales", "inventory_snapshot", "service_level", "slow_movers", "inventory_planning", "product_fetch"]
            }
        }
        
    except Exception as e:
        logger.error(f"Error checking cron status: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Error checking cron status: {str(e)}")