from typing import List, Optional

from fastapi import APIRouter, Depends, HTTPException, Query, BackgroundTasks
from sqlalchemy.orm import Session
from app.core.database import get_db
from app.api.deps import get_current_user
from app.tasks.background_tasks import process_marketplace_import
from middleware.decorators import rate_limit
from models.api_models import MarketplaceImportJobResponse, MarketplaceImportRequest
from models.database_models import User, MarketplaceImportJob, Shop
from datetime import datetime
import logging

router = APIRouter()
logger = logging.getLogger(__name__)


# Marketplace Import Routes (Protected)
@router.post("/import-from-marketplace", response_model=MarketplaceImportJobResponse)
@rate_limit(max_requests=10, window_seconds=3600)  # Limit marketplace imports
async def import_products_from_marketplace(
        request: MarketplaceImportRequest,
        background_tasks: BackgroundTasks,
        db: Session = Depends(get_db),
        current_user: User = Depends(get_current_user)
):
    """Import products from marketplace CSV with background processing (Protected)"""

    logger.info(
        f"Starting marketplace import: {request.marketplace} -> {request.shop_code} by user {current_user.username}")

    # Verify shop exists and user has access
    shop = db.query(Shop).filter(Shop.shop_code == request.shop_code).first()
    if not shop:
        raise HTTPException(status_code=404, detail="Shop not found")

    # Check permissions: admin can import for any shop, others only for their own
    if current_user.role != "admin" and shop.owner_id != current_user.id:
        raise HTTPException(status_code=403, detail="Access denied to this shop")

    # Create marketplace import job record
    import_job = MarketplaceImportJob(
        status="pending",
        source_url=request.url,
        marketplace=request.marketplace,
        shop_code=request.shop_code,
        user_id=current_user.id,
        created_at=datetime.utcnow()
    )
    db.add(import_job)
    db.commit()
    db.refresh(import_job)

    # Process in background
    background_tasks.add_task(
        process_marketplace_import,
        import_job.id,
        request.url,
        request.marketplace,
        request.shop_code,
        request.batch_size or 1000
    )

    return MarketplaceImportJobResponse(
        job_id=import_job.id,
        status="pending",
        marketplace=request.marketplace,
        shop_code=request.shop_code,
        message=f"Marketplace import started from {request.marketplace}. Check status with "
                f"/marketplace-import-status/{import_job.id}"
    )


@router.get("/marketplace-import-status/{job_id}", response_model=MarketplaceImportJobResponse)
def get_marketplace_import_status(
        job_id: int,
        db: Session = Depends(get_db),
        current_user: User = Depends(get_current_user)
):
    """Get status of marketplace import job (Protected)"""
    job = db.query(MarketplaceImportJob).filter(MarketplaceImportJob.id == job_id).first()
    if not job:
        raise HTTPException(status_code=404, detail="Marketplace import job not found")

    # Users can only see their own jobs, admins can see all
    if current_user.role != "admin" and job.user_id != current_user.id:
        raise HTTPException(status_code=403, detail="Access denied to this import job")

    return MarketplaceImportJobResponse(
        job_id=job.id,
        status=job.status,
        marketplace=job.marketplace,
        shop_name=job.shop_name,
        imported=job.imported_count or 0,
        updated=job.updated_count or 0,
        total_processed=job.total_processed or 0,
        error_count=job.error_count or 0,
        error_message=job.error_message,
        created_at=job.created_at,
        started_at=job.started_at,
        completed_at=job.completed_at
    )


@router.get("/marketplace-import-jobs", response_model=List[MarketplaceImportJobResponse])
def get_marketplace_import_jobs(
        marketplace: Optional[str] = Query(None, description="Filter by marketplace"),
        shop_name: Optional[str] = Query(None, description="Filter by shop name"),
        skip: int = Query(0, ge=0),
        limit: int = Query(50, ge=1, le=100),
        db: Session = Depends(get_db),
        current_user: User = Depends(get_current_user)
):
    """Get marketplace import jobs with filtering (Protected)"""

    query = db.query(MarketplaceImportJob)

    # Users can only see their own jobs, admins can see all
    if current_user.role != "admin":
        query = query.filter(MarketplaceImportJob.user_id == current_user.id)

    # Apply filters
    if marketplace:
        query = query.filter(MarketplaceImportJob.marketplace.ilike(f"%{marketplace}%"))
    if shop_name:
        query = query.filter(MarketplaceImportJob.shop_name.ilike(f"%{shop_name}%"))

    # Order by creation date (newest first) and apply pagination
    jobs = query.order_by(MarketplaceImportJob.created_at.desc()).offset(skip).limit(limit).all()

    return [
        MarketplaceImportJobResponse(
            job_id=job.id,
            status=job.status,
            marketplace=job.marketplace,
            shop_name=job.shop_name,
            imported=job.imported_count or 0,
            updated=job.updated_count or 0,
            total_processed=job.total_processed or 0,
            error_count=job.error_count or 0,
            error_message=job.error_message,
            created_at=job.created_at,
            started_at=job.started_at,
            completed_at=job.completed_at
        ) for job in jobs
    ]