cloud-reporter/backend/app/api/tasks.py

"""
Task Management API endpoints

Provides endpoints for:
- GET /api/tasks - Get paginated list of tasks with status filtering
- POST /api/tasks/create - Create a new scan task
- POST /api/tasks/upload-scan - Upload CloudShell scan data and create task
- GET /api/tasks/detail - Get task details
- POST /api/tasks/delete - Delete a task
- GET /api/tasks/logs - Get task logs with pagination

Requirements: 3.1, 3.4, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6
"""
import os
import json
import uuid
import redis
from datetime import datetime
from flask import jsonify, request, current_app
from werkzeug.utils import secure_filename

from app import db
from app.api import api_bp
from app.models import Task, TaskLog, AWSCredential, UserCredential
from app.services import login_required, admin_required, get_current_user_from_context, check_credential_access
from app.services.scan_data_processor import ScanDataProcessor
from app.errors import ValidationError, NotFoundError, AuthorizationError


ALLOWED_IMAGE_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'bmp'}


def allowed_file(filename: str) -> bool:
    """Check if file extension is allowed for network diagram"""
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_IMAGE_EXTENSIONS


@api_bp.route('/tasks', methods=['GET'])
@login_required
def get_tasks():
    """
    Get paginated list of tasks with optional status filtering.
    
    Query Parameters:
        page: Page number (default: 1)
        page_size: Items per page (default: 20, max: 100)
        status: Optional filter by status (pending, running, completed, failed)
    
    Returns:
        JSON with 'data' array and 'pagination' object
    """
    current_user = get_current_user_from_context()
    
    # Get pagination parameters
    page = request.args.get('page', 1, type=int)
    # Support both pageSize (frontend) and page_size (backend convention)
    page_size = request.args.get('pageSize', type=int) or request.args.get('page_size', type=int) or 20
    page_size = min(page_size, 100)
    status = request.args.get('status', type=str)
    
    # Validate pagination
    if page < 1:
        page = 1
    if page_size < 1:
        page_size = 20
    
    # Build query based on user role
    if current_user.role in ['admin', 'power_user']:
        query = Task.query
    else:
        # Regular users can only see their own tasks
        query = Task.query.filter_by(created_by=current_user.id)
    
    # Apply status filter if provided
    if status and status in ['pending', 'running', 'completed', 'failed']:
        query = query.filter_by(status=status)
    
    # Order by created_at descending
    query = query.order_by(Task.created_at.desc())
    
    # Get total count
    total = query.count()
    total_pages = (total + page_size - 1) // page_size if total > 0 else 1
    
    # Apply pagination
    tasks = query.offset((page - 1) * page_size).limit(page_size).all()
    
    return jsonify({
        'data': [task.to_dict() for task in tasks],
        'pagination': {
            'page': page,
            'page_size': page_size,
            'total': total,
            'total_pages': total_pages
        }
    }), 200


@api_bp.route('/tasks/create', methods=['POST'])
@login_required
def create_task():
    """
    Create a new scan task.
    
    Request Body (JSON or multipart/form-data):
        name: Task name (required)
        credential_ids: List of credential IDs to use (required)
        regions: List of AWS regions to scan (required)
        project_metadata: Project metadata object (required)
            - clientName: Client name (required)
            - projectName: Project name (required)
            - bdManager: BD Manager name (optional)
            - bdManagerEmail: BD Manager email (optional)
            - solutionsArchitect: Solutions Architect name (optional)
            - solutionsArchitectEmail: Solutions Architect email (optional)
            - cloudEngineer: Cloud Engineer name (optional)
            - cloudEngineerEmail: Cloud Engineer email (optional)
        network_diagram: Network diagram image file (optional, multipart only)
    
    Returns:
        JSON with created task details and task_id
    """
    current_user = get_current_user_from_context()
    
    # Handle both JSON and multipart/form-data
    if request.content_type and 'multipart/form-data' in request.content_type:
        data = request.form.to_dict()
        # Parse JSON fields from form data
        import json
        if 'credential_ids' in data:
            data['credential_ids'] = json.loads(data['credential_ids'])
        if 'regions' in data:
            data['regions'] = json.loads(data['regions'])
        if 'project_metadata' in data:
            data['project_metadata'] = json.loads(data['project_metadata'])
        network_diagram = request.files.get('network_diagram')
    else:
        data = request.get_json() or {}
        network_diagram = None
    
    # Validate required fields
    if not data.get('name'):
        raise ValidationError(
            message="Task name is required",
            details={"missing_fields": ["name"]}
        )
    
    credential_ids = data.get('credential_ids', [])
    if not credential_ids or not isinstance(credential_ids, list) or len(credential_ids) == 0:
        raise ValidationError(
            message="At least one credential must be selected",
            details={"missing_fields": ["credential_ids"]}
        )
    
    regions = data.get('regions', [])
    if not regions or not isinstance(regions, list) or len(regions) == 0:
        raise ValidationError(
            message="At least one region must be selected",
            details={"missing_fields": ["regions"]}
        )
    
    project_metadata = data.get('project_metadata', {})
    if not isinstance(project_metadata, dict):
        raise ValidationError(
            message="Project metadata must be an object",
            details={"field": "project_metadata", "reason": "invalid_type"}
        )
    
    # Validate required project metadata fields
    required_metadata = ['clientName', 'projectName']
    missing_metadata = [field for field in required_metadata if not project_metadata.get(field)]
    if missing_metadata:
        raise ValidationError(
            message="Missing required project metadata fields",
            details={"missing_fields": missing_metadata}
        )
    
    # Validate clientName and projectName don't contain invalid filename characters
    import re
    invalid_chars_pattern = r'[<>\/\\|*:?"]'
    client_name = project_metadata.get('clientName', '')
    project_name = project_metadata.get('projectName', '')
    
    if re.search(invalid_chars_pattern, client_name):
        raise ValidationError(
            message="Client name contains invalid characters",
            details={"field": "clientName", "reason": "Cannot contain < > / \\ | * : ? \""}
        )
    
    if re.search(invalid_chars_pattern, project_name):
        raise ValidationError(
            message="Project name contains invalid characters",
            details={"field": "projectName", "reason": "Cannot contain < > / \\ | * : ? \""}
        )
    
    # Validate credential access for regular users
    for cred_id in credential_ids:
        if not check_credential_access(current_user, cred_id):
            raise AuthorizationError(
                message=f"Access denied to credential {cred_id}",
                details={"credential_id": cred_id, "reason": "not_assigned"}
            )
        
        # Verify credential exists and is active
        credential = db.session.get(AWSCredential, cred_id)
        if not credential:
            raise NotFoundError(
                message=f"Credential {cred_id} not found",
                details={"credential_id": cred_id}
            )
        if not credential.is_active:
            raise ValidationError(
                message=f"Credential {cred_id} is not active",
                details={"credential_id": cred_id, "reason": "inactive"}
            )
    
    # Handle network diagram upload
    network_diagram_path = None
    if network_diagram and network_diagram.filename:
        if not allowed_file(network_diagram.filename):
            raise ValidationError(
                message="Invalid file type for network diagram. Allowed: png, jpg, jpeg, gif, bmp",
                details={"field": "network_diagram", "reason": "invalid_file_type"}
            )
        
        # Save the file
        uploads_folder = current_app.config.get('UPLOAD_FOLDER', 'uploads')
        os.makedirs(uploads_folder, exist_ok=True)
        
        filename = secure_filename(network_diagram.filename)
        # Add timestamp to avoid conflicts
        import time
        filename = f"{int(time.time())}_{filename}"
        network_diagram_path = os.path.join(uploads_folder, filename)
        network_diagram.save(network_diagram_path)
        
        # Store path in project metadata
        project_metadata['network_diagram_path'] = network_diagram_path
    
    # Create task
    task = Task(
        name=data['name'].strip(),
        status='pending',
        progress=0,
        created_by=current_user.id
    )
    task.credential_ids = credential_ids
    task.regions = regions
    task.project_metadata = project_metadata
    
    db.session.add(task)
    db.session.commit()
    
    # Dispatch to Celery
    celery_task = None
    
    try:
        # 先测试Redis连接
        import redis
        print(f"🔍 测试Redis连接...")
        broker_url = current_app.config.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
        r = redis.from_url(broker_url)
        r.ping()
        print(f"✅ Redis连接成功")
        
        # 导入并初始化Celery应用
        from app.celery_app import celery_app, init_celery
        init_celery(current_app._get_current_object())
        print(f"✅ Celery初始化完成, broker: {celery_app.conf.broker_url}")
        
        # 导入Celery任务
        from app.tasks.scan_tasks import scan_aws_resources
        print(f"✅ 任务模块导入成功")
        
        # 提交任务
        print(f"🔍 提交任务到Celery队列...")
        celery_task = scan_aws_resources.delay(
            task_id=task.id,
            credential_ids=credential_ids,
            regions=regions,
            project_metadata=project_metadata
        )
        print(f"✅ 任务已提交: {celery_task.id}")
        
    except redis.ConnectionError as e:
        # Redis连接失败，删除已创建的任务并返回错误
        db.session.delete(task)
        db.session.commit()
        raise ValidationError(
            message="Redis服务不可用，无法创建任务。请确保Redis服务已启动。",
            details={"error": str(e)}
        )
    except Exception as e:
        # 其他错误
        db.session.delete(task)
        db.session.commit()
        raise ValidationError(
            message="任务提交失败",
            details={"error": str(e), "error_type": type(e).__name__}
        )
    
    # Store Celery task ID
    task.celery_task_id = celery_task.id
    db.session.commit()
    
    return jsonify({
        'message': 'Task created successfully',
        'task': task.to_dict(),
        'celery_task_id': celery_task.id
    }), 201


@api_bp.route('/tasks/upload-scan', methods=['POST'])
@login_required
def upload_scan():
    """
    Upload CloudShell scan data and create a task.
    
    This endpoint accepts JSON scan data from CloudShell scanner and creates
    a task for report generation without requiring AWS credentials.
    
    Request Body (multipart/form-data):
        scan_data: JSON file containing CloudShell scan results (required, max 50MB)
        project_metadata: JSON string with project metadata (required)
            - clientName: Client name (required)
            - projectName: Project name (required)
            - bdManager: BD Manager name (optional)
            - bdManagerEmail: BD Manager email (optional)
            - solutionsArchitect: Solutions Architect name (optional)
            - solutionsArchitectEmail: Solutions Architect email (optional)
            - cloudEngineer: Cloud Engineer name (optional)
            - cloudEngineerEmail: Cloud Engineer email (optional)
        network_diagram: Network diagram image file (optional)
    
    Returns:
        JSON with created task details
    
    Requirements:
        - 4.1: Provide API endpoint to receive uploaded JSON data
        - 4.2: Validate JSON structure completeness
        - 4.5: Return detailed error information if validation fails
        - 4.6: Support large file uploads (max 50MB)
    """
    import re
    import redis
    
    current_user = get_current_user_from_context()
    
    # Check content type
    if not request.content_type or 'multipart/form-data' not in request.content_type:
        raise ValidationError(
            message="Content-Type must be multipart/form-data",
            details={"expected": "multipart/form-data", "received": request.content_type}
        )
    
    # Get scan_data file
    scan_data_file = request.files.get('scan_data')
    if not scan_data_file or not scan_data_file.filename:
        raise ValidationError(
            message="scan_data file is required",
            details={"missing_fields": ["scan_data"]}
        )
    
    # Validate file extension
    if not scan_data_file.filename.lower().endswith('.json'):
        raise ValidationError(
            message="scan_data must be a JSON file",
            details={"field": "scan_data", "reason": "invalid_file_type", "expected": ".json"}
        )
    
    # Read and parse JSON data
    try:
        scan_data_content = scan_data_file.read()
        # Check file size (50MB limit)
        max_size = current_app.config.get('MAX_CONTENT_LENGTH', 50 * 1024 * 1024)
        if len(scan_data_content) > max_size:
            raise ValidationError(
                message="File size exceeds limit",
                details={"max_size": f"{max_size // (1024 * 1024)}MB", "field": "scan_data"}
            )
        
        scan_data = json.loads(scan_data_content.decode('utf-8'))
    except json.JSONDecodeError as e:
        raise ValidationError(
            message="Invalid JSON format",
            details={"error": str(e), "field": "scan_data"}
        )
    except UnicodeDecodeError as e:
        raise ValidationError(
            message="Invalid file encoding. File must be UTF-8 encoded",
            details={"error": str(e), "field": "scan_data"}
        )
    
    # Validate scan data structure using ScanDataProcessor
    processor = ScanDataProcessor()
    is_valid, validation_errors = processor.validate_scan_data(scan_data)
    
    if not is_valid:
        raise ValidationError(
            message="Invalid scan data structure",
            details={"validation_errors": validation_errors, "missing_fields": validation_errors}
        )
    
    # Parse project_metadata from form data
    project_metadata_str = request.form.get('project_metadata')
    if not project_metadata_str:
        raise ValidationError(
            message="project_metadata is required",
            details={"missing_fields": ["project_metadata"]}
        )
    
    try:
        project_metadata = json.loads(project_metadata_str)
    except json.JSONDecodeError as e:
        raise ValidationError(
            message="Invalid project_metadata JSON format",
            details={"error": str(e), "field": "project_metadata"}
        )
    
    if not isinstance(project_metadata, dict):
        raise ValidationError(
            message="project_metadata must be a JSON object",
            details={"field": "project_metadata", "reason": "invalid_type"}
        )
    
    # Validate required project metadata fields
    required_metadata = ['clientName', 'projectName']
    missing_metadata = [field for field in required_metadata if not project_metadata.get(field)]
    if missing_metadata:
        raise ValidationError(
            message="Missing required project metadata fields",
            details={"missing_fields": missing_metadata}
        )
    
    # Validate clientName and projectName don't contain invalid filename characters
    invalid_chars_pattern = r'[<>\/\\|*:?"]'
    client_name = project_metadata.get('clientName', '')
    project_name = project_metadata.get('projectName', '')
    
    if re.search(invalid_chars_pattern, client_name):
        raise ValidationError(
            message="Client name contains invalid characters",
            details={"field": "clientName", "reason": "Cannot contain < > / \\ | * : ? \""}
        )
    
    if re.search(invalid_chars_pattern, project_name):
        raise ValidationError(
            message="Project name contains invalid characters",
            details={"field": "projectName", "reason": "Cannot contain < > / \\ | * : ? \""}
        )
    
    # Handle network diagram upload
    network_diagram_path = None
    network_diagram = request.files.get('network_diagram')
    if network_diagram and network_diagram.filename:
        if not allowed_file(network_diagram.filename):
            raise ValidationError(
                message="Invalid file type for network diagram. Allowed: png, jpg, jpeg, gif, bmp",
                details={"field": "network_diagram", "reason": "invalid_file_type"}
            )
        
        # Save the file
        uploads_folder = current_app.config.get('UPLOAD_FOLDER', 'uploads')
        os.makedirs(uploads_folder, exist_ok=True)
        
        filename = secure_filename(network_diagram.filename)
        import time
        filename = f"{int(time.time())}_{filename}"
        network_diagram_path = os.path.join(uploads_folder, filename)
        network_diagram.save(network_diagram_path)
        
        # Store path in project metadata
        project_metadata['network_diagram_path'] = network_diagram_path
    
    # Save scan data to file
    scan_data_folder = current_app.config.get('SCAN_DATA_FOLDER', 'uploads/scan_data')
    os.makedirs(scan_data_folder, exist_ok=True)
    
    # Generate unique filename for scan data
    scan_data_filename = f"scan_{uuid.uuid4().hex}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    scan_data_path = os.path.join(scan_data_folder, scan_data_filename)
    
    # Write scan data to file
    with open(scan_data_path, 'w', encoding='utf-8') as f:
        json.dump(scan_data, f, ensure_ascii=False, indent=2)
    
    # Extract metadata from scan data
    metadata = scan_data.get('metadata', {})
    account_id = metadata.get('account_id', 'Unknown')
    regions_scanned = metadata.get('regions_scanned', [])
    
    # Create task name
    task_name = f"CloudShell Scan - {account_id} - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
    
    # Create task with source='upload'
    task = Task(
        name=task_name,
        status='pending',
        progress=0,
        created_by=current_user.id,
        source='upload',
        scan_data_path=scan_data_path
    )
    task.credential_ids = []  # No credentials for upload tasks
    task.regions = regions_scanned
    task.project_metadata = project_metadata
    
    db.session.add(task)
    db.session.commit()
    
    # Dispatch to Celery for processing
    celery_task = None
    
    try:
        # Test Redis connection
        broker_url = current_app.config.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
        r = redis.from_url(broker_url)
        r.ping()
        
        # Initialize Celery
        from app.celery_app import celery_app, init_celery
        init_celery(current_app._get_current_object())
        
        # Import and dispatch task
        from app.tasks.scan_tasks import process_uploaded_scan
        
        celery_task = process_uploaded_scan.delay(
            task_id=task.id,
            scan_data_path=scan_data_path,
            project_metadata=project_metadata
        )
        
    except redis.ConnectionError as e:
        # Redis connection failed, delete task and scan data file
        db.session.delete(task)
        db.session.commit()
        if os.path.exists(scan_data_path):
            os.remove(scan_data_path)
        raise ValidationError(
            message="Redis服务不可用，无法创建任务。请确保Redis服务已启动。",
            details={"error": str(e)}
        )
    except Exception as e:
        # Other errors
        db.session.delete(task)
        db.session.commit()
        if os.path.exists(scan_data_path):
            os.remove(scan_data_path)
        raise ValidationError(
            message="任务提交失败",
            details={"error": str(e), "error_type": type(e).__name__}
        )
    
    # Store Celery task ID
    task.celery_task_id = celery_task.id
    db.session.commit()
    
    return jsonify({
        'message': '任务创建成功',
        'task': task.to_dict(),
        'celery_task_id': celery_task.id
    }), 201


@api_bp.route('/tasks/detail', methods=['GET'])
@login_required
def get_task_detail():
    """
    Get task details including current status and progress.
    
    Query Parameters:
        id: Task ID (required)
    
    Returns:
        JSON with task details
    """
    current_user = get_current_user_from_context()
    task_id = request.args.get('id', type=int)
    
    if not task_id:
        raise ValidationError(
            message="Task ID is required",
            details={"missing_fields": ["id"]}
        )
    
    task = db.session.get(Task, task_id)
    if not task:
        raise NotFoundError(
            message="Task not found",
            details={"task_id": task_id}
        )
    
    # Check access for regular users
    if current_user.role == 'user' and task.created_by != current_user.id:
        raise AuthorizationError(
            message="Access denied",
            details={"reason": "not_owner"}
        )
    
    # Get task details with additional info
    task_dict = task.to_dict()
    
    # Add report info if available
    if task.report:
        task_dict['report'] = task.report.to_dict()
    
    # Add error count
    error_count = TaskLog.query.filter_by(task_id=task_id, level='error').count()
    task_dict['error_count'] = error_count
    
    # Get Celery task status if running
    if task.status == 'running' and task.celery_task_id:
        from celery.result import AsyncResult
        from app.celery_app import celery_app
        
        result = AsyncResult(task.celery_task_id, app=celery_app)
        if result.state == 'PROGRESS':
            task_dict['celery_progress'] = result.info
    
    return jsonify(task_dict), 200


@api_bp.route('/tasks/delete', methods=['POST'])
@login_required
def delete_task():
    """
    Delete a task and its associated logs and report.
    
    Request Body:
        id: Task ID (required)
    
    Returns:
        JSON with success message
    """
    current_user = get_current_user_from_context()
    data = request.get_json() or {}
    task_id = data.get('id')
    
    if not task_id:
        raise ValidationError(
            message="Task ID is required",
            details={"missing_fields": ["id"]}
        )
    
    task = db.session.get(Task, task_id)
    if not task:
        raise NotFoundError(
            message="Task not found",
            details={"task_id": task_id}
        )
    
    # Check access - only admin or task owner can delete
    if current_user.role != 'admin' and task.created_by != current_user.id:
        raise AuthorizationError(
            message="Access denied",
            details={"reason": "not_owner_or_admin"}
        )
    
    # Cannot delete running tasks
    if task.status == 'running':
        raise ValidationError(
            message="Cannot delete a running task",
            details={"task_id": task_id, "status": task.status}
        )
    
    # Delete associated report file if exists
    if task.report and task.report.file_path:
        try:
            if os.path.exists(task.report.file_path):
                os.remove(task.report.file_path)
        except OSError:
            pass  # File may already be deleted
    
    # Delete task (cascade will handle logs and report)
    db.session.delete(task)
    db.session.commit()
    
    return jsonify({
        'message': 'Task deleted successfully'
    }), 200


@api_bp.route('/tasks/logs', methods=['GET'])
@login_required
def get_task_logs():
    """
    Get paginated task logs.
    
    Query Parameters:
        id: Task ID (required)
        page: Page number (default: 1)
        page_size: Items per page (default: 20, max: 100)
        level: Optional filter by log level (info, warning, error)
    
    Returns:
        JSON with 'data' array and 'pagination' object
    
    Requirements:
        - 8.3: Display error logs associated with task
    """
    current_user = get_current_user_from_context()
    task_id = request.args.get('id', type=int)
    
    if not task_id:
        raise ValidationError(
            message="Task ID is required",
            details={"missing_fields": ["id"]}
        )
    
    task = db.session.get(Task, task_id)
    if not task:
        raise NotFoundError(
            message="Task not found",
            details={"task_id": task_id}
        )
    
    # Check access for regular users
    if current_user.role == 'user' and task.created_by != current_user.id:
        raise AuthorizationError(
            message="Access denied",
            details={"reason": "not_owner"}
        )
    
    # Get pagination parameters
    page = request.args.get('page', 1, type=int)
    # Support both pageSize (frontend) and page_size (backend convention)
    page_size = request.args.get('pageSize', type=int) or request.args.get('page_size', type=int) or 20
    page_size = min(page_size, 100)
    level = request.args.get('level', type=str)
    
    # Validate pagination
    if page < 1:
        page = 1
    if page_size < 1:
        page_size = 20
    
    # Build query
    query = TaskLog.query.filter_by(task_id=task_id)
    
    # Apply level filter if provided
    if level and level in ['info', 'warning', 'error']:
        query = query.filter_by(level=level)
    
    # Order by created_at descending
    query = query.order_by(TaskLog.created_at.desc())
    
    # Get total count
    total = query.count()
    total_pages = (total + page_size - 1) // page_size if total > 0 else 1
    
    # Apply pagination
    logs = query.offset((page - 1) * page_size).limit(page_size).all()
    
    return jsonify({
        'data': [log.to_dict() for log in logs],
        'pagination': {
            'page': page,
            'page_size': page_size,
            'total': total,
            'total_pages': total_pages
        }
    }), 200


@api_bp.route('/tasks/errors', methods=['GET'])
@login_required
def get_task_errors():
    """
    Get error logs for a specific task.
    
    This is a convenience endpoint that returns only error-level logs
    with full details including stack traces.
    
    Query Parameters:
        id: Task ID (required)
        page: Page number (default: 1)
        page_size: Items per page (default: 20, max: 100)
    
    Returns:
        JSON with 'data' array containing error logs and 'pagination' object
    
    Requirements:
        - 8.2: Record error details in task record
        - 8.3: Display error logs associated with task
    """
    current_user = get_current_user_from_context()
    task_id = request.args.get('id', type=int)
    
    if not task_id:
        raise ValidationError(
            message="Task ID is required",
            details={"missing_fields": ["id"]}
        )
    
    task = db.session.get(Task, task_id)
    if not task:
        raise NotFoundError(
            message="Task not found",
            details={"task_id": task_id}
        )
    
    # Check access for regular users
    if current_user.role == 'user' and task.created_by != current_user.id:
        raise AuthorizationError(
            message="Access denied",
            details={"reason": "not_owner"}
        )
    
    # Get pagination parameters
    page = request.args.get('page', 1, type=int)
    # Support both pageSize (frontend) and page_size (backend convention)
    page_size = request.args.get('pageSize', type=int) or request.args.get('page_size', type=int) or 20
    page_size = min(page_size, 100)
    
    # Validate pagination
    if page < 1:
        page = 1
    if page_size < 1:
        page_size = 20
    
    # Build query for error logs only
    query = TaskLog.query.filter_by(task_id=task_id, level='error')
    
    # Order by created_at descending
    query = query.order_by(TaskLog.created_at.desc())
    
    # Get total count
    total = query.count()
    total_pages = (total + page_size - 1) // page_size if total > 0 else 1
    
    # Apply pagination
    logs = query.offset((page - 1) * page_size).limit(page_size).all()
    
    # Build response with full error details
    error_data = []
    for log in logs:
        log_dict = log.to_dict()
        # Ensure details are included for error analysis
        error_data.append(log_dict)
    
    return jsonify({
        'data': error_data,
        'pagination': {
            'page': page,
            'page_size': page_size,
            'total': total,
            'total_pages': total_pages
        },
        'summary': {
            'total_errors': total,
            'task_status': task.status
        }
    }), 200