import json
import re
import argparse
from collections import Counter
import warnings
warnings.filterwarnings("ignore")


def normalize_prediction_text(pred_text):
    if pred_text is None:
        return "[EMPTY]"
    pred_text = pred_text.strip()
    return pred_text if pred_text else "[EMPTY]"


def exact_entity_match(ent_text, pred_text):
    if not ent_text or not pred_text:
        return False
    pattern = rf"(?<!\w){re.escape(ent_text)}(?!\w)"
    return re.search(pattern, pred_text, flags=re.IGNORECASE) is not None


def entity_leakage_rate(gold_records, predictions):
    leaked = 0
    total = 0
    per_type = Counter()
    leaked_per_type = Counter()

    for g, p in zip(gold_records, predictions):
        pred_text = normalize_prediction_text(p.get("anonymized_text", ""))
        for ent in g.get("entities", []):
            ent_text = ent.get("text", "")
            ent_type = ent.get("type", "UNKNOWN") or "UNKNOWN"
            total += 1
            per_type[ent_type] += 1
            if exact_entity_match(ent_text, pred_text):
                leaked += 1
                leaked_per_type[ent_type] += 1

    elr = leaked / total if total > 0 else 0.0
    return elr * 100, leaked, total, per_type, leaked_per_type

def get_capitalized_ngrams(text, n=3):
    """Extract n-grams where at least one token starts with uppercase."""
    tokens = text.split()
    ngrams = [tuple(tokens[i:i+n]) for i in range(len(tokens)-n+1)]
    return [ng for ng in ngrams if any(len(t) > 0 and t[0].isupper() for t in ng)]

def crr3(gold_records, predictions):
    """Capitalized 3-gram survival rate."""
    survived = 0
    total = 0
    
    for g, p in zip(gold_records, predictions):
        orig_3grams = get_capitalized_ngrams(g.get("original_text", ""), n=3)
        pred_text = normalize_prediction_text(p.get("anonymized_text", "")).lower()
        
        for ng in orig_3grams:
            total += 1
            if " ".join(ng).lower() in pred_text:
                survived += 1
                
    crr = survived / total if total > 0 else 0.0
    return crr * 100

def calculate_bertscore(gold_records, predictions, model_type="distilbert-base-uncased"):
    """
    BERTScore F1 computes the semantic similarity of the texts.
    Pinned model for reproducible benchmarking computations.
    """
    try:
        from bert_score import score
    except ImportError:
        print("`bert_score` not installed. Skipping. Install with: pip install bert_score")
        return None
        
    refs = [g.get("original_text", "") for g in gold_records]
    cands = [normalize_prediction_text(p.get("anonymized_text", "")) for p in predictions]
    
    P, R, F1 = score(cands, refs, lang="en", verbose=False, model_type=model_type)
    return F1.mean().item() * 100

def main():
    parser = argparse.ArgumentParser(description="SAHA-AL Benchmark Evaluator")
    parser.add_argument("--gold", type=str, default="data/test.jsonl", help="Path to gold dataset (e.g. test.jsonl)")
    parser.add_argument("--pred", type=str, required=True, help="Path to predictions JSONL")
    parser.add_argument("--bert-model", type=str, default="distilbert-base-uncased",
                        help="Model to use for BERTScore (e.g., microsoft/deberta-xlarge-mnli)")
    parser.add_argument("--print-types", action="store_true", help="Print per-entity-type ELR breakdown")
    parser.add_argument("--summary-file", type=str, default=None,
                        help="Optional JSON file to write evaluation results to")
    args = parser.parse_args()
    
    with open(args.gold, "r", encoding="utf-8") as f:
        gold_records = [json.loads(line) for line in f]
        
    with open(args.pred, "r", encoding="utf-8") as f:
        predictions = [json.loads(line) for line in f]
        
    unknown_entity_count = 0
    total_entity_count = 0

    for g, p in zip(gold_records, predictions):
        if g.get("id") != p.get("id"):
            raise ValueError(f"ID mismatch: {g.get('id')} vs {p.get('id')}")

        for ent in g.get("entities", []):
            total_entity_count += 1
            if ent.get("type", "UNKNOWN") == "UNKNOWN":
                unknown_entity_count += 1

    if total_entity_count > 0 and unknown_entity_count > 0:
        pct = (unknown_entity_count / total_entity_count) * 100
        print(f"[NOTE] {pct:.1f}% of entities in evaluation are typed as UNKNOWN.")

    print(f"Evaluating {len(predictions)} records...")

    elr, leaked, total_ents, per_type, leaked_per_type = entity_leakage_rate(gold_records, predictions)
    crr_3 = crr3(gold_records, predictions)
    bert_f1 = calculate_bertscore(gold_records, predictions, model_type=args.bert_model)
    
    print("\n" + "="*40)
    print(" SAHA-AL Benchmark Results")
    print("="*40)
    print(f" Entity Leakage Rate (ELR ↓): {elr:5.2f}% ({leaked}/{total_ents} leaked)")
    print(f" Contextual Re-ID (CRR-3 ↓):  {crr_3:5.2f}%")
    if bert_f1 is not None:
        print(f" BERTScore (F1 ↑):            {bert_f1:5.2f} (Model: {args.bert_model})")
    else:
        print(f" BERTScore (F1 ↑):            N/A")

    if args.print_types:
        print("\nPer-entity-type ELR:")
        for ent_type, count in per_type.most_common():
            leaked_count = leaked_per_type.get(ent_type, 0)
            elr_type = (leaked_count / count * 100) if count > 0 else 0.0
            print(f"  {ent_type:15} {elr_type:5.2f}% ({leaked_count}/{count})")

    print("="*40)

    if args.summary_file:
        summary = {
            "gold": args.gold,
            "predictions": args.pred,
            "records": len(predictions),
            "elr": round(elr, 2),
            "leaked": leaked,
            "total_entities": total_ents,
            "crr_3": round(crr_3, 2),
            "bert_f1": round(bert_f1, 2) if bert_f1 is not None else None,
            "bert_model": args.bert_model,
            "entity_types": {
                ent_type: {
                    "count": count,
                    "leaked": leaked_per_type.get(ent_type, 0),
                    "elr": round((leaked_per_type.get(ent_type, 0) / count * 100) if count > 0 else 0.0, 2),
                }
                for ent_type, count in per_type.items()
            },
        }
        with open(args.summary_file, "w", encoding="utf-8") as f:
            json.dump(summary, f, indent=2)
        print(f"Summary written to: {args.summary_file}")

if __name__ == "__main__":
    main()