import asyncio
from arc_scorer import ARCScorer

async def main():
    # Initialize the scorer
    scorer = ARCScorer(
        api_key="your_api_key_here",
        base_url="https://api.openai.com/v1",
        model_name="gpt-4o-mini",
        verbose=True
    )
    
    # Score a summary against a cached article
    article_id = "1995canlii6138.txt"
    summary = """This court case involved a plaintiff who claimed injury from a 
    childhood car accident. The plaintiff consulted a lawyer 5 years after reaching 
    majority and sought to revive her claim. Justice Wright dismissed the defendants' 
    application to dismiss the case, noting that infants with legitimate claims 
    should not be penalized for previous legal representatives' mistakes."""
    
    # Compute ARCScore
    result = await scorer.score_summary(article_id, summary)
    
    print(f"ARCScore: {result['average_recall']:.2%}")
    print(f"Components evaluated: {result['num_components']}")

if __name__ == "__main__":
    asyncio.run(main())

"""
Example usage of ARCScore with CANLII legal case summaries.
Demonstrates loading cached decompositions and computing bottom-up recall.
"""

import asyncio
from arc_scorer import ARCScorer

async def main():
    # Initialize scorer with your LLM credentials
    scorer = ARCScorer(
        api_key="your_api_key_here",
        base_url="https://api.openai.com/v1",
        model_name="gpt-4o-mini",
        verbose=True
    )
    
    # Check cache statistics
    stats = scorer.cache_stats()
    print(f"✓ Cache loaded: {stats['total_entries']} decomposition instances")
    print(f"  Cache file: {stats['cache_file']}\n")
    
    # Example article and summary
    article_id = "1995canlii6138.txt"
    summary = """This court case, Diane Soron vs. Albert Lavoie et al, involved 
    a plaintiff who claimed she had been injured by a car accident when she was a 
    child. The plaintiff, now an adult, consulted a lawyer 5 years after reaching 
    majority and sought to revive her original claim. The defendants applied to 
    dismiss the case due to the delay and lack of evidence.

    Justice Wright considered several factors in making his decision. He had sympathy 
    for the defendants, who had destroyed their files and had a key witness pass away. 
    However, Wright noted that the initial lawyer may have continued to represent the 
    plaintiff after the initial consultation. Furthermore, medical records from the 
    accident should still exist.

    Wright was influenced by the principle that infants with legitimate claims should 
    not be penalized for mistakes of previous legal representatives. Despite the 
    challenges, Wright dismissed the defendants' application to dismiss the case."""
    
    # Check what components are available in cache
    all_components = scorer.cache.get_all_components(article_id)
    if all_components:
        print(f"✓ Found {sum(len(v) for v in all_components.values())} "
              f"decomposition instances:")
        for comp_type, instances in all_components.items():
            print(f"    {comp_type}: {len(instances)} instances")
        print()
        
        # Show detailed breakdown of components
        print("Component Details:")
        for comp_type, instances in all_components.items():
            for i, inst in enumerate(instances):
                print(f"  [{comp_type}_{i}] {len(inst.atomic_facts)} atomic facts")
                print(f"       Text: {inst.component_text[:80]}...")
        print()
    
    # Compute ARCScore (bottom-up: per-component then averaged)
    print(f"Computing ARCScore for article {article_id}...\n")
    
    result = await scorer.score_summary(article_id, summary)
    
    # Display results
    print(f"=" * 70)
    print(f"ARCScore Results:")
    print(f"=" * 70)
    print(f"  Article ID: {result['article_id']}")
    print(f"  Summary length: {result['summary_length']} words")
    print(f"  Number of components: {result['num_components']}")
    print(f"  Average Recall (article-level): {result['average_recall']:.2%}")
    print()
    
    # Per-component breakdown
    if result['per_component_results']:
        print(f"  Per-Component Breakdown:")
        print(f"  " + "-" * 66)
        for comp_result in result['per_component_results']:
            print(f"    [{comp_result['component_type']}]")
            print(f"      Text: {comp_result['component_text'][:60]}...")
            print(f"      Total facts: {comp_result['total_facts']}")
            print(f"      Verified facts: {comp_result['verified_facts']}")
            print(f"      Recall: {comp_result['recall']:.2%}")
            print()

if __name__ == "__main__":
    asyncio.run(main())

from arc_scorer import ARCScorer, DecompositionResult, AtomicFact

# Initialize with custom cache directory
scorer = ARCScorer(
    api_key="your_key",
    base_url="https://api.openai.com/v1",
    model_name="gpt-4o",
    cache_dir="./my_custom_cache"
)

# Add a custom decomposition to cache
custom_decomp = DecompositionResult(
    article_id="doc123",
    component_type="Argument",
    component_text="The court ruled that...",
    atomic_facts=[
        AtomicFact(
            fact_id="fact1",
            text="The court ruled in favor of the plaintiff",
            component_type="Argument",
            source="doc123"
        )
    ],
    decomposed_at=time.time()
)

scorer.cache.put(custom_decomp)

async def score_multiple_summaries(scorer, articles_and_summaries):
    """Score multiple summaries in parallel."""
    tasks = [
        scorer.score_summary(article_id, summary)
        for article_id, summary in articles_and_summaries
    ]
    results = await asyncio.gather(*tasks)
    return results

# Usage
articles = [
    ("doc1.txt", "Summary of document 1..."),
    ("doc2.txt", "Summary of document 2..."),
    ("doc3.txt", "Summary of document 3..."),
]

results = asyncio.run(score_multiple_summaries(scorer, articles))
for result in results:
    print(f"{result['article_id']}: {result['average_recall']:.2%}")

# Azure OpenAI
scorer = ARCScorer(
    api_key="your_openai_key",
    base_url="url",
    model_name="gpt-4",
    verbose=True
)

# Local LLM (e.g., via VLLM serve)
scorer = ARCScorer(
    api_key="not-needed",
    base_url="http://localhost:1234/v1",
    model_name="local-model",
    verbose=True
)

ARCScorer(
    api_key: str,              # LLM API key
    base_url: str,             # LLM API base URL
    model_name: str,           # Model name (e.g., "gpt-4o-mini")
    cache_dir: str = None,     # Cache directory (default: ./cache)
    prompts_dir: str = None,   # Prompts directory (default: ./prompts)
    temperature: float = 0,    # Sampling temperature
    is_reasoning: bool = False,# Whether model supports reasoning
    verbose: bool = False      # Print verification details
)

{
    "article_id": str,              # Document identifier
    "summary_length": int,          # Word count
    "num_components": int,          # Number of components evaluated
    "average_recall": float,        # Article-level recall (0-1)
    "per_component_results": [      # Detailed breakdown
        {
            "component_type": str,   # e.g., "Issue", "Holding"
            "component_text": str,   # Original text
            "total_facts": int,      # Number of atomic facts
            "verified_facts": int,   # Facts found in summary
            "recall": float          # Component-level recall (0-1)
        },
        ...
    ]
}