ui/leaderboard_tab.py

"""
리더보드 탭 UI 컴포넌트

🏆 Leaderboard 탭의 UI와 로직을 관리합니다.
"""

import gradio as gr
import pandas as pd
from src.leaderboard_manager import load_leaderboard_data


def create_leaderboard_tab():
    """리더보드 탭 UI 생성"""
    
    # 최상단 통합 검색 바 - 개선된 디자인
    with gr.Row():
        with gr.Column(scale=12):
            search_input = gr.Textbox(
                label="제출자 이름 검색",
                placeholder="🔍 제출자 이름으로 검색...",
                value="",
                container=False,
                elem_classes=["search-input"]
            )
        with gr.Column(scale=1, min_width=100):
            clear_search_btn = gr.Button(
                "🗑️ 초기화", 
                variant="secondary", 
                size="sm",
                elem_classes=["clear-search-btn"]
            )
        with gr.Column(scale=1, min_width=100):
            refresh_btn = gr.Button(
                "🔄 새로고침", 
                variant="primary",
                size="sm",
                elem_classes=["refresh-btn"]
            )

    # 리더보드 노출 컬럼 및 표시명 설정
    DISPLAY_COLUMNS = [
        'rank',
        'id',
        'model',
        'description',
        'accuracy',
        'fast_changing_accuracy',
        'slow_changing_accuracy',
        'never_changing_accuracy',
        'acc_vp',
        'acc_fp',
        'acc_vp_one_hop',
        'acc_vp_two_hop',
        'acc_fp_one_hop',
        'acc_fp_two_hop',
        'acc_politics',
        'acc_sports',
        'acc_entertainment',
        'acc_weather',
        'acc_world',
        'acc_economy',
        'acc_society',
        'acc_it_science',
        'acc_life_culture',
        'acc_unknown'
    ]
    
    COLUMN_LABELS = {
        'rank': 'Rank',
        'id': 'ID',
        'model': 'Model',
        'description': 'Description',
        'accuracy': 'Accuracy',
        'fast_changing_accuracy': 'Fast-changing',
        'slow_changing_accuracy': 'Slow-changing',
        'never_changing_accuracy': 'Never-changing',
        'acc_vp': 'Valid Premise',
        'acc_fp': 'False Premise',
        'acc_vp_one_hop': 'VP One-hop',
        'acc_vp_two_hop': 'VP Multi-hop',
        'acc_fp_one_hop': 'FP One-hop',
        'acc_fp_two_hop': 'FP Multi-hop',
        'acc_politics': 'Politics',
        'acc_sports': 'Sports',
        'acc_entertainment': 'Entertainment',
        'acc_weather': 'Weather',
        'acc_world': 'World',
        'acc_economy': 'Economy',
        'acc_society': 'Society',
        'acc_it_science': 'IT/Science',
        'acc_life_culture': 'Life/Culture',
        'acc_unknown': 'Unknown'
    }

    def prepare_display_data(df: pd.DataFrame, global_ranking=None) -> pd.DataFrame:
        """테이블 표시용 데이터 준비 (rank 계산 및 반올림 적용)"""
        # 빈 데이터프레임인 경우 그대로 반환
        if df is None or df.empty:
            return df if df is not None else pd.DataFrame()

        display_df = df.copy()

        # model / description 기본값 처리
        if "model" in display_df.columns:
            display_df["model"] = display_df["model"].fillna("Anonymous Model")
            display_df["model"] = display_df["model"].replace("", "Anonymous Model")
        if "description" in display_df.columns:
            display_df["description"] = (
                display_df["description"]
                .replace({None: "", pd.NA: ""})
                .fillna("")
            )

        # rank 컬럼 추가
        if "accuracy" in display_df.columns:
            if global_ranking is not None:
                # 외부에서 전체 랭킹 정보를 제공하는 경우
                display_df["rank"] = display_df.index.map(global_ranking)
            else:
                # accuracy 기준으로 정렬하여 rank 계산
                display_df = display_df.sort_values("accuracy", ascending=False).reset_index(
                    drop=True
                )

                def get_rank_display(rank: int) -> str:
                    if rank == 1:
                        return "🥇"
                    elif rank == 2:
                        return "🥈"
                    elif rank == 3:
                        return "🥉"
                    else:
                        return str(rank)

                display_df["rank"] = [get_rank_display(i + 1) for i in range(len(display_df))]

        # 숫자 컬럼들을 소숫점 2번째에서 반올림 (표시용으로만)
        numeric_columns = [
            "accuracy",
            "fast_changing_accuracy",
            "slow_changing_accuracy",
            "never_changing_accuracy",
            "acc_vp",
            "acc_fp",
            "acc_vp_one_hop",
            "acc_vp_two_hop",
            "acc_fp_one_hop",
            "acc_fp_two_hop",
            "acc_vp_old",
            "acc_vp_new",
            "acc_fp_old",
            "acc_fp_new",
            "acc_politics",
            "acc_sports",
            "acc_entertainment",
            "acc_weather",
            "acc_world",
            "acc_economy",
            "acc_society",
            "acc_it_science",
            "acc_life_culture",
            "acc_unknown",
        ]

        for col in numeric_columns:
            if col in display_df.columns:
                display_df[col] = display_df[col].round(2)

        return display_df

    
    def format_leaderboard(df: pd.DataFrame) -> pd.DataFrame:
        """리더보드에 노출할 컬럼 선택 및 헤더명 변환"""
        if df.empty:
            # 빈 DataFrame일 때도 컬럼 구조를 유지하기 위해 빈 DataFrame 생성
            empty_df = pd.DataFrame(columns=DISPLAY_COLUMNS)
            rename_map = {col: COLUMN_LABELS[col] for col in DISPLAY_COLUMNS if col in COLUMN_LABELS}
            return empty_df.rename(columns=rename_map)
        
        selected_columns = [col for col in DISPLAY_COLUMNS if col in df.columns]
        formatted_df = df[selected_columns].copy()
        rename_map = {col: COLUMN_LABELS[col] for col in selected_columns if col in COLUMN_LABELS}
        return formatted_df.rename(columns=rename_map)
    
    def build_leaderboard_state(source_df: pd.DataFrame):
        """리더보드 표시용 Relaxed/Strict 데이터와 빈 상태 여부 반환"""
        if source_df is None:
            source_df = pd.DataFrame()

        if source_df.empty or 'evaluation_mode' not in source_df.columns:
            relaxed_df = pd.DataFrame()
            strict_df = pd.DataFrame()
        else:
            relaxed_df = source_df.query("evaluation_mode == 'Relaxed'")
            strict_df = source_df.query("evaluation_mode == 'Strict'")

        formatted_relaxed = format_leaderboard(prepare_display_data(relaxed_df))
        formatted_strict = format_leaderboard(prepare_display_data(strict_df))
        is_empty = relaxed_df.empty and strict_df.empty
        return formatted_relaxed, formatted_strict, is_empty

    # ✅ 초기 값 (앱 빌드 시점 기준)
    leaderboard_data = load_leaderboard_data()
    relaxed_initial, strict_initial, is_initial_empty = build_leaderboard_state(leaderboard_data)

    # Relaxed 모드 리더보드
    with gr.Column(elem_classes=["leaderboard-group"]):
        gr.Markdown(
            "### 🟢 Relaxed Evaluation"
        )

        relaxed_leaderboard_table = gr.DataFrame(
            value=relaxed_initial,
            interactive=False,
            wrap=False,
            show_label=False,
            elem_classes=["leaderboard-table"]
        )
    
    # Strict 모드 리더보드
    with gr.Column(elem_classes=["leaderboard-group"]):
        gr.Markdown(
            "### 🔴 Strict Evaluation"
        )
        
        strict_leaderboard_table = gr.DataFrame(
            value=strict_initial,
            interactive=False,
            wrap=False,
            show_label=False,
            elem_classes=["leaderboard-table"]
        )
    
    # 리더보드 관련 설명
    with gr.Column(elem_classes=["leaderboard-group"]):
        gr.Markdown("""
            이 리더보드는 [FreshQA](https://github.com/freshllms/freshqa)에서 영감을 받아 만들어졌습니다.  
            fact type(fast changing, slow changing, never changing), 전제의 진실성,  
            10개의 도메인에 따라 나뉘는 질문들을 통해 한국어 지식과 관련된 LLM의 최신성을 판단할 수 있습니다.

            이 리더보드는 IITP의 **“생성형 언어모델의 지속가능성과 시간의 흐름에 따른 최신성 반영을 위한 학습 및 활용 기술 개발”** 사업의 지원을 받아 제작되었습니다.

            결과의 무결성·유효성을 유지하고 **순위 조작을 방지**하기 위해 평가 데이터셋의 정답은 기밀로 유지됩니다.
        """)


    # 통합 검색 필터 함수 (Relaxed와 Strict 모드 모두 필터링)
    def filter_leaderboard_data(search_text):
        """Relaxed와 Strict 모드 리더보드 데이터 필터링 (CSV 기반)"""
        try:
            # CSV에서 전체 데이터 로드
            all_df = load_leaderboard_data()

            # 검색 필터 적용 (제출자 정보만 검색)
            if search_text.strip() and 'id' in all_df.columns:
                mask = all_df['id'].str.contains(search_text, case=False, na=False)
                filtered_df = all_df[mask]
            else:
                filtered_df = all_df

            formatted_relaxed, formatted_strict, _ = build_leaderboard_state(filtered_df)
            return formatted_relaxed, formatted_strict
        except Exception as e:
            print(f"❌ 리더보드 데이터 필터링 실패: {e}")
            empty = pd.DataFrame()
            return empty, empty
    
    # 검색 이벤트 연결
    search_input.change(
        fn=filter_leaderboard_data,
        inputs=[search_input],
        outputs=[relaxed_leaderboard_table, strict_leaderboard_table]
    )
    
    # 검색 초기화 버튼
    def clear_search():
        try:
            all_df = load_leaderboard_data()
            formatted_relaxed, formatted_strict, _ = build_leaderboard_state(all_df)
            return "", formatted_relaxed, formatted_strict
        except Exception as e:
            print(f"❌ 리더보드 데이터 로드 실패: {e}")
            empty = pd.DataFrame()
            return "", empty, empty
    
    clear_search_btn.click(
        fn=clear_search,
        outputs=[search_input, relaxed_leaderboard_table, strict_leaderboard_table]
    )
    
    # 새로고침 버튼
    def refresh_leaderboard():
        try:
            all_df = load_leaderboard_data()
            formatted_relaxed, formatted_strict, is_empty = build_leaderboard_state(all_df)
            return formatted_relaxed, formatted_strict
        except Exception as e:
            print(f"❌ 리더보드 새로고침 실패: {e}")
            empty = pd.DataFrame()
            return empty, empty
    
    refresh_btn.click(
        fn=refresh_leaderboard,
        outputs=[relaxed_leaderboard_table, strict_leaderboard_table]
    )

    # ✅ app.py에서 초기 로딩 시에도 재사용할 수 있도록 return
    return relaxed_leaderboard_table, strict_leaderboard_table, refresh_leaderboard