"""
Utility functions for file processing status determination.
"""

from typing import Dict, List

from sqlalchemy.orm import Session

from app.models import FileProcessingStep, ProcessingLog
from app.utils.step_manager import get_file_overall_status, get_step_summary


def get_file_processing_status(db: Session, file_id: int) -> Dict:
    """
    Get the processing status for a file by checking its processing steps.

    This function now queries the FileProcessingStep table instead of scanning logs.

    Args:
        db: Database session
        file_id: ID of the file

    Returns:
        dict with status, last_step, and has_errors
    """
    # Use the new status table approach
    overall_status = get_file_overall_status(db, file_id)

    # Get the most recently updated step to determine last_step
    latest_step = (
        db.query(FileProcessingStep)
        .filter(FileProcessingStep.file_id == file_id)
        .order_by(FileProcessingStep.updated_at.desc())
        .first()
    )

    return {
        "status": overall_status["status"],
        "last_step": latest_step.step_name if latest_step else None,
        "has_errors": overall_status["has_errors"],
        "total_steps": overall_status["total_steps"],
    }


def get_files_processing_status(db: Session, file_ids: List[int]) -> Dict[int, Dict]:
    """
    Get processing status for multiple files efficiently.

    Args:
        db: Database session
        file_ids: List of file IDs

    Returns:
        dict mapping file_id to status dict
    """
    # Get all steps for these files in one query
    steps = db.query(FileProcessingStep).filter(FileProcessingStep.file_id.in_(file_ids)).all()

    # Group steps by file_id
    steps_by_file = {}
    for step in steps:
        if step.file_id not in steps_by_file:
            steps_by_file[step.file_id] = []
        steps_by_file[step.file_id].append(step)

    # Compute status for each file
    result = {}
    for file_id in file_ids:
        file_steps = steps_by_file.get(file_id, [])
        if not file_steps:
            result[file_id] = {"status": "pending", "last_step": None, "has_errors": False, "total_steps": 0}
        else:
            # Compute overall status from steps
            total_steps = len(file_steps)
            completed_steps = sum(1 for s in file_steps if s.status == "success")
            failed_steps = sum(1 for s in file_steps if s.status == "failure")
            in_progress_steps = sum(1 for s in file_steps if s.status == "in_progress")
            skipped_steps = sum(1 for s in file_steps if s.status == "skipped")

            has_errors = failed_steps > 0

            # Determine overall status
            if has_errors:
                status = "failed"
            elif in_progress_steps > 0:
                status = "processing"
            elif completed_steps + skipped_steps == total_steps:
                status = "completed"
            else:
                status = "pending"

            # Get last updated step
            latest_step = max(file_steps, key=lambda s: s.updated_at if s.updated_at else s.created_at)

            result[file_id] = {
                "status": status,
                "last_step": latest_step.step_name,
                "has_errors": has_errors,
                "total_steps": total_steps,
            }

    return result


def _compute_status_from_logs(logs: List[ProcessingLog]) -> Dict:
    """
    Compute processing status from a list of processing logs.

    DEPRECATED: This function is kept for backwards compatibility.
    New code should use the FileProcessingStep table instead.

    Args:
        logs: List of ProcessingLog objects (should be ordered by timestamp desc)

    Returns:
        dict with status, last_step, has_errors, and total_steps
    """
    if not logs:
        return {"status": "pending", "last_step": None, "has_errors": False, "total_steps": 0}

    # Get the latest status for each unique step
    # Since logs are ordered by timestamp desc, the first occurrence is the latest
    latest_by_step = {}
    for log in logs:
        if log.step_name not in latest_by_step:
            latest_by_step[log.step_name] = log

    # Check for failures in latest statuses
    has_errors = any(log.status == "failure" for log in latest_by_step.values())

    # Check if any step is currently in progress (based on latest status per step)
    in_progress = any(log.status == "in_progress" for log in latest_by_step.values())

    # Get the overall latest log
    latest_log = logs[0]

    # Determine overall status
    if has_errors:
        status = "failed"
    elif in_progress:
        status = "processing"
    elif latest_log.status == "success":
        status = "completed"
    else:
        status = "pending"

    return {"status": status, "last_step": latest_log.step_name, "has_errors": has_errors, "total_steps": len(logs)}