from __future__ import annotations

from typing import Dict, List, Literal, Optional

import numpy as np
import pandas as pd


class Leaderboard:
    def __init__(self, data_loader):
        self.data_loader = data_loader
        self.metric_better: Dict[str, Literal["min", "max"]] = {
            metric: "min" if metric in data_loader.lower_better else "max"
            for metric in data_loader.ALL_METRICS
        }
        self.dimension_metrics = list(data_loader.DIMENSION_METRICS)

    def update_leaderboard(
        self,
        metric: str,
        top_k: int,
        model_filter: str,
        entry_type_filter: str,
        sort_mode: str,
        selected_metrics: Optional[List[str]],
    ) -> pd.DataFrame:
        if self.data_loader.df_all is None or self.data_loader.df_all.empty:
            return pd.DataFrame()

        df = self.data_loader.df_all.copy()
        if metric not in df.columns:
            return pd.DataFrame()

        if model_filter and model_filter.strip():
            df = df[df["Model"].str.contains(model_filter, case=False, na=False)]

        if entry_type_filter and entry_type_filter != "All":
            df = df[df["entry_type"] == entry_type_filter]

        better = self.metric_better.get(metric, "max")
        if sort_mode == "Auto":
            ascending = better == "min"
        elif sort_mode == "Ascending (low → high)":
            ascending = True
        else:
            ascending = False

        df_sorted = df.dropna(subset=[metric]).sort_values(metric, ascending=ascending).copy()
        df_sorted["Rank"] = range(1, len(df_sorted) + 1)
        df_top = df_sorted.head(top_k).copy()

        fixed_cols = ["Model", "entry_type", metric, "Rank"]
        selected_metrics = selected_metrics or []
        filtered_selected_metrics = [metric_name for metric_name in selected_metrics if metric_name not in fixed_cols]
        existing_cols = [col for col in fixed_cols + filtered_selected_metrics if col in df_top.columns]
        table_df = df_top[existing_cols].copy()

        for col in table_df.columns:
            if col in {"Model", "entry_type"}:
                continue
            if col == "Rank":
                table_df[col] = table_df[col].apply(lambda value: f"{int(value)}" if pd.notna(value) else "N/A")
            else:
                table_df[col] = table_df[col].apply(lambda value: f"{value:.2f}" if pd.notna(value) else "N/A")

        return self._add_styling_to_dataframe(table_df)

    def _add_styling_to_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
        styled_df = df.copy()
        numeric_cols = [col for col in df.columns if col not in ["Model", "entry_type", "Rank"]]

        for col in numeric_cols:
            try:
                numeric_values = df[col].apply(lambda value: float(value) if value != "N/A" and pd.notna(value) else np.nan)
            except Exception:
                continue

            valid_values = numeric_values.dropna()
            if len(valid_values) < 1:
                continue

            better = self.metric_better.get(col, "max")
            sorted_values = valid_values.sort_values(ascending=(better == "min"))

            try:
                best_idx = sorted_values.index[0]
                best_val = df.loc[best_idx, col]
                if pd.notna(best_val) and best_val != "N/A":
                    styled_df.loc[best_idx, col] = f"**{best_val}**"

                if len(sorted_values) >= 2:
                    second_idx = sorted_values.index[1]
                    second_val = df.loc[second_idx, col]
                    if pd.notna(second_val) and second_val != "N/A":
                        styled_df.loc[second_idx, col] = f"<u>{second_val}</u>"
            except (IndexError, KeyError, ValueError):
                continue

        return styled_df