"""
Data formatting utilities for Gradio display.
Handles formatting of model names, scores, and table structure.
"""

import pandas as pd
from .data_loader import get_benchmark_info


def format_score(score_value):
    """
    Format a benchmark score for display.

    Args:
        score_value: Score value (float, int, or None)

    Returns:
        str: Formatted score ("85.3" or "—" for missing)
    """
    if pd.isna(score_value) or score_value is None:
        return "—"
    return f"{score_value:.1f}"


def format_model_name_with_provider(row):
    """
    Create model name display with provider initials prefix.

    Args:
        row: DataFrame row with 'model_name', 'provider' columns

    Returns:
        str: Model name with provider prefix (e.g., "[HF] mistralai/Mistral-7B")
    """
    model_name = row["model_name"]
    provider = row["provider"]

    # Add provider initials as prefix
    initials = provider[:3].upper() if provider else "???"
    return f"[{initials}] {model_name}"


def format_hf_link(row):
    """
    Create HuggingFace link for the model.

    Args:
        row: DataFrame row with 'model_name' column

    Returns:
        str: HuggingFace URL
    """
    model_name = row["model_name"]
    return f"https://huggingface.co/{model_name}"


def format_for_display(df, selected_benchmarks):
    """
    Format dataframe for Gradio display.

    Args:
        df (pd.DataFrame): Filtered leaderboard dataframe
        selected_benchmarks (list): List of benchmark keys to display

    Returns:
        pd.DataFrame: Formatted dataframe ready for gr.Dataframe
    """
    if df.empty:
        # Return empty dataframe with proper structure
        return pd.DataFrame(columns=["Model", "Parameters", "🔗 Link"])

    display_df = df.copy()

    # Create model column with provider prefix
    display_df["Model"] = display_df.apply(format_model_name_with_provider, axis=1)

    # Create HF link column
    display_df["HF Link"] = display_df.apply(format_hf_link, axis=1)

    # Start with base columns
    columns_to_show = ["Model", "parameters_display", "HF Link"]
    column_names = ["Model", "Parameters", "🔗 Link"]

    # Get benchmark info for display names
    benchmark_info = get_benchmark_info()

    # Add selected benchmark columns
    for bench_key in selected_benchmarks:
        score_col = f"{bench_key}_score"

        if score_col in display_df.columns:
            # Get display name from benchmark info
            display_name = benchmark_info.get(bench_key, {}).get("name", bench_key)

            # Format scores
            display_df[display_name] = display_df[score_col].apply(format_score)

            columns_to_show.append(display_name)
            column_names.append(display_name)

    # Select only the columns we want to show
    result_df = display_df[columns_to_show].copy()

    # Rename columns for clarity
    result_df.columns = column_names

    return result_df


def create_empty_table(selected_benchmarks):
    """
    Create an empty table with proper column structure.

    Args:
        selected_benchmarks (list): List of benchmark keys

    Returns:
        pd.DataFrame: Empty dataframe with proper columns
    """
    benchmark_info = get_benchmark_info()

    columns = ["Model", "Parameters", "🔗 Link"]

    for bench_key in selected_benchmarks:
        display_name = benchmark_info.get(bench_key, {}).get("name", bench_key)
        columns.append(display_name)

    return pd.DataFrame(columns=columns)


def get_column_datatypes(selected_benchmarks):
    """
    Get Gradio datatype specification for table columns.

    Args:
        selected_benchmarks (list): List of benchmark keys

    Returns:
        list: List of datatype strings for gr.Dataframe
    """
    # Base columns: Model (str), Provider (str), Parameters (str)
    datatypes = ["str", "str", "str"]

    # Add 'str' for each benchmark column (they're pre-formatted as strings)
    for _ in selected_benchmarks:
        datatypes.append("str")

    return datatypes


def prepare_export_data(df, selected_benchmarks):
    """
    Prepare data for CSV export (without HTML/markdown formatting).

    Args:
        df (pd.DataFrame): Filtered leaderboard dataframe
        selected_benchmarks (list): List of benchmark keys

    Returns:
        pd.DataFrame: Clean dataframe for CSV export
    """
    if df.empty:
        return pd.DataFrame()

    export_df = df[["model_name", "provider", "parameters_display"]].copy()
    export_df.columns = ["Model", "Provider", "Parameters"]

    benchmark_info = get_benchmark_info()

    # Add benchmark scores
    for bench_key in selected_benchmarks:
        score_col = f"{bench_key}_score"
        if score_col in df.columns:
            display_name = benchmark_info.get(bench_key, {}).get("name", bench_key)
            export_df[display_name] = df[score_col].apply(format_score)

    return export_df