# ============================================================================
# OCR-Noised IR Evaluation Script
# ============================================================================
# Evaluates embedding models on OCR-noised information retrieval benchmarks
# hosted on Hugging Face Hub.
#
# Datasets (both share the same HF schema):
#   ocr-miracl  — OCR-degraded subset of miracl/miracl
#   ocr-mldr    — OCR-degraded subset of mteb/MultiLongDocRetrieval
#
# Each (lang, dpi) config contains three splits:
#   corpus:  _id, clean_text, ocr_text
#   queries: _id, clean_text, ocr_text
#   qrels:   query_id, corpus_id, score
#
# Evaluation modes:
#   clean      : encode clean corpus & clean queries  (upper bound)
#   ocr        : encode OCR corpus & OCR queries      (realistic OCR)
#   clean2ocr  : encode clean corpus & OCR queries     (noisy query)
#   ocr2clean  : encode OCR corpus & clean queries     (noisy index)
#
# Metrics: NDCG@10, MRR@10, Recall@100
#
# Usage:
#   pip install datasets sentence-transformers torch numpy pandas
#   python evaluation_IR.py \
#       --model Alibaba-NLP/gte-multilingual-base \
#       --dataset <hf_org>/ocr-miracl \
#       --dpi dpi120_font10 \
#       --langs de en es fr ru \
#       --mode ocr \
#       --batch_size 64
# ============================================================================

import os
os.environ["TOKENIZERS_PARALLELISM"] = "false"

import argparse
import gc
import time
import numpy as np
import pandas as pd
import torch
from datetime import datetime
from typing import List, Dict
from datasets import load_dataset
from sentence_transformers import SentenceTransformer

# ======================= IR METRICS =======================

def compute_ndcg(relevance: List[int], k: int = 10) -> float:
    dcg = sum(rel / np.log2(i + 2) for i, rel in enumerate(relevance[:k]))
    ideal = sorted(relevance, reverse=True)[:k]
    idcg = sum(rel / np.log2(i + 2) for i, rel in enumerate(ideal))
    return dcg / idcg if idcg > 0 else 0.0


def compute_mrr(relevance: List[int], k: int = 10) -> float:
    for i, rel in enumerate(relevance[:k]):
        if rel > 0:
            return 1.0 / (i + 1)
    return 0.0


def compute_recall(relevance: List[int], total_relevant: int, k: int = 100) -> float:
    if total_relevant == 0:
        return 0.0
    return sum(1 for rel in relevance[:k] if rel > 0) / total_relevant


# ======================= HELPERS =======================

def reset_cuda():
    gc.collect()
    if torch.cuda.is_available():
        torch.cuda.empty_cache()


def load_eval_model(model_name_or_path: str) -> SentenceTransformer:
    return SentenceTransformer(model_name_or_path, trust_remote_code=True)


def resolve_text_columns(mode: str):
    """
    Return (corpus_text_col, query_text_col) for the given mode.
    Modes: clean, ocr, clean2ocr, ocr2clean
    """
    mapping = {
        "clean":     ("clean_text", "clean_text"),
        "ocr":       ("ocr_text",   "ocr_text"),
        "clean2ocr": ("clean_text", "ocr_text"),
        "ocr2clean": ("ocr_text",   "clean_text"),
    }
    if mode not in mapping:
        raise ValueError(f"Unknown mode '{mode}'. Choose from: {list(mapping.keys())}")
    return mapping[mode]


# ======================= EVALUATION =======================

def evaluate_language(
    model: SentenceTransformer,
    dataset_repo: str,
    lang: str,
    dpi: str,
    mode: str = "ocr",
    batch_size: int = 64,
) -> Dict:
    """
    Evaluate a single (lang, dpi) configuration.
    Returns a dict with ndcg@10, mrr@10, recall@100.
    """
    config_name = f"{lang}_{dpi}"
    corpus_col, query_col = resolve_text_columns(mode)

    print(f"\n  [{lang.upper()}] Loading {config_name} ...", end=" ", flush=True)

    try:
        corpus_ds = load_dataset(dataset_repo, data_dir=f"data/{config_name}_corpus", split="test")
        queries_ds = load_dataset(dataset_repo, data_dir=f"data/{config_name}_queries", split="test")
        qrels_ds = load_dataset(dataset_repo, data_dir=f"data/{config_name}_qrels", split="test")
        print(f"OK  ({len(corpus_ds)} docs, {len(queries_ds)} queries, {len(qrels_ds)} qrels)")
    except Exception as e:
        print(f"FAIL: {e}")
        return {f"{lang}_error": str(e)}

    # Texts to encode
    corpus_ids = corpus_ds["_id"]
    corpus_texts = corpus_ds[corpus_col]
    query_ids = queries_ds["_id"]
    query_texts = queries_ds[query_col]

    # Build qrels dict: {query_id: {corpus_id: score}}
    qrels_dict: Dict[str, Dict[str, int]] = {}
    for row in qrels_ds:
        qid = row["query_id"]
        if qid not in qrels_dict:
            qrels_dict[qid] = {}
        qrels_dict[qid][row["corpus_id"]] = row["score"]

    # Encode
    print(f"  [{lang.upper()}] Encoding corpus ({len(corpus_texts)} docs)...")
    corpus_emb = model.encode(
        corpus_texts, batch_size=batch_size,
        show_progress_bar=True, normalize_embeddings=True,
    )

    print(f"  [{lang.upper()}] Encoding queries ({len(query_texts)} queries)...")
    query_emb = model.encode(
        query_texts, batch_size=batch_size,
        show_progress_bar=True, normalize_embeddings=True,
    )

    # Cosine similarity (embeddings are L2-normalised)
    similarities = np.dot(query_emb, corpus_emb.T)

    ndcg_scores, mrr_scores, recall_scores = [], [], []

    for i, qid in enumerate(query_ids):
        if qid not in qrels_dict:
            continue

        top_indices = np.argsort(similarities[i])[::-1][:100]
        relevance = [qrels_dict[qid].get(corpus_ids[idx], 0) for idx in top_indices]
        total_relevant = sum(1 for v in qrels_dict[qid].values() if v > 0)

        ndcg_scores.append(compute_ndcg(relevance, k=10))
        mrr_scores.append(compute_mrr(relevance, k=10))
        recall_scores.append(compute_recall(relevance, total_relevant, k=100))

    result = {
        f"{lang}_ndcg@10": np.mean(ndcg_scores) if ndcg_scores else 0.0,
        f"{lang}_mrr@10": np.mean(mrr_scores) if mrr_scores else 0.0,
        f"{lang}_recall@100": np.mean(recall_scores) if recall_scores else 0.0,
        f"{lang}_num_queries": len(ndcg_scores),
    }
    print(f"  [{lang.upper()}] ndcg@10={result[f'{lang}_ndcg@10']:.4f}  "
          f"mrr@10={result[f'{lang}_mrr@10']:.4f}  "
          f"recall@100={result[f'{lang}_recall@100']:.4f}")
    return result


def evaluate_model(
    model_name: str,
    dataset_repo: str,
    dpi: str,
    langs: List[str],
    mode: str = "ocr",
    batch_size: int = 64,
) -> Dict:
    """Evaluate one model across all requested languages."""

    print(f"\n{'='*60}")
    print(f"Model:   {model_name}")
    print(f"Dataset: {dataset_repo}")
    print(f"DPI:     {dpi}")
    print(f"Mode:    {mode}")
    print(f"Langs:   {langs}")
    print(f"{'='*60}")

    result = {"model": model_name, "dataset": dataset_repo, "dpi": dpi, "mode": mode}
    t0 = time.time()

    model = load_eval_model(model_name)

    for i, lang in enumerate(langs):
        print(f"\n  [{i+1}/{len(langs)}]", end="")
        try:
            lang_result = evaluate_language(
                model, dataset_repo, lang, dpi, mode, batch_size
            )
            result.update(lang_result)
        except Exception as e:
            print(f"  [{lang.upper()}] Error: {e}")
            result[f"{lang}_error"] = str(e)

    del model
    reset_cuda()

    # Compute averages
    ndcg_cols = [v for k, v in result.items() if k.endswith("_ndcg@10")]
    mrr_cols = [v for k, v in result.items() if k.endswith("_mrr@10")]
    recall_cols = [v for k, v in result.items() if k.endswith("_recall@100")]
    if ndcg_cols:
        result["avg_ndcg@10"] = np.mean(ndcg_cols)
    if mrr_cols:
        result["avg_mrr@10"] = np.mean(mrr_cols)
    if recall_cols:
        result["avg_recall@100"] = np.mean(recall_cols)

    result["time_min"] = round((time.time() - t0) / 60, 1)
    return result


# ======================= CLI =======================

def parse_args():
    parser = argparse.ArgumentParser(
        description="Evaluate embedding models on OCR-noised IR benchmarks"
    )
    parser.add_argument(
        "--model", type=str, nargs="+", required=True,
        help="HF model name(s) or local path(s), e.g. Alibaba-NLP/gte-multilingual-base",
    )
    parser.add_argument(
        "--dataset", type=str, required=True,
        help="HF dataset repo, e.g. <org>/ocr-miracl or <org>/ocr-mldr",
    )
    parser.add_argument(
        "--dpi", type=str, nargs="+", default=["dpi120_font10"],
        help="DPI config(s) to evaluate (default: dpi120_font10)",
    )
    parser.add_argument(
        "--langs", type=str, nargs="+", default=["de", "en", "es", "fr", "ru"],
        help="Languages to evaluate",
    )
    parser.add_argument(
        "--mode", type=str, nargs="+", default=["ocr"],
        choices=["clean", "ocr", "clean2ocr", "ocr2clean"],
        help="Text mode(s): clean, ocr, clean2ocr, ocr2clean",
    )
    parser.add_argument("--batch_size", type=int, default=64)
    parser.add_argument("--output_dir", type=str, default="./ir_results")
    return parser.parse_args()


# ======================= MAIN =======================

if __name__ == "__main__":
    args = parse_args()
    os.makedirs(args.output_dir, exist_ok=True)

    print(f"\nPyTorch: {torch.__version__}")
    print(f"CUDA: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        print(f"GPU: {torch.cuda.get_device_name(0)}")

    all_results = []

    for model_name in args.model:
        for dpi in args.dpi:
            for mode in args.mode:
                reset_cuda()
                result = evaluate_model(
                    model_name, args.dataset, dpi, args.langs,
                    mode=mode, batch_size=args.batch_size,
                )
                all_results.append(result)

                # Save incremental results
                df = pd.DataFrame(all_results)
                df.to_csv(os.path.join(args.output_dir, "results_progress.csv"), index=False)

    # Final save
    df = pd.DataFrame(all_results)
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    final_path = os.path.join(args.output_dir, f"results_{ts}.csv")
    latest_path = os.path.join(args.output_dir, "results_latest.csv")
    df.to_csv(final_path, index=False)
    df.to_csv(latest_path, index=False)

    print(f"\n{'='*70}")
    print("RESULTS")
    print(f"{'='*70}")
    print(df.to_string(index=False))
    print(f"\nSaved to: {final_path}")