import ollama
import PyPDF2
from pathlib import Path

def extract_text_from_pdf(pdf_path: Path) -> str:
    """Extract text from PDF while preserving structure."""
    with open(pdf_path, 'rb') as file:
        reader = PyPDF2.PdfReader(file)
        text = ""
        for page in reader.pages:
            text += page.extract_text() + "\n\n"
    return text

def analyze_research_papers(paper_paths: list[Path]) -> dict:
    """
    Analyze multiple research papers using full context.
    No chunking, no RAG complexity, no cloud APIs.
    """
    # Load all papers into single context
    combined_text = ""
    for i, path in enumerate(paper_paths, 1):
        paper_text = extract_text_from_pdf(path)
        combined_text += f"\n\n=== PAPER {i}: {path.name} ===\n\n{paper_text}"

    # Single prompt with complete context
    prompt = f"""
    You are analyzing multiple research papers simultaneously. 
    The complete text of all papers is provided below.

    Please provide:
    1. Common methodologies across papers
    2. Contradicting findings or approaches
    3. Research gaps identified by comparing all papers
    4. Synthesis of key contributions

    Papers:
    {combined_text}
    """

    response = ollama.chat(
        model='gemma4:31b-it-q4_K_M',
        messages=[{
            'role': 'user',
            'content': prompt
        }]
    )

    return response['message']['content']

# Example usage
papers = [
    Path("paper1_transformers.pdf"),
    Path("paper2_attention_mechanisms.pdf"),
    Path("paper3_scaling_laws.pdf")
]

analysis = analyze_research_papers(papers)
print(analysis)

def review_contract_package(contract_paths: list[Path]) -> dict:
    """
    Comprehensive contract review with full context.
    All documents loaded simultaneously for cross-reference analysis.
    """
    full_contract = ""
    for path in contract_paths:
        doc_text = extract_text_from_pdf(path)
        full_contract += f"\n\n=== {path.name} ===\n\n{doc_text}"

    review_prompt = f"""
    You are reviewing a complete contract package for a technology company.

    Analyze the following and provide specific citations:

    1. Data residency and sovereignty requirements
    2. Liability caps and limitations across all documents
    3. Termination rights and notice periods
    4. IP ownership and licensing terms
    5. Security and compliance obligations
    6. Any contradictions between documents

    For each finding, cite the specific document and section.

    Complete Contract Package:
    {full_contract}
    """

    response = ollama.chat(
        model='gemma4:31b-it-q4_K_M',
        messages=[{
            'role': 'user',
            'content': review_prompt
        }]
    )

    return {
        'summary': response['message']['content'],
        'token_count': len(full_contract.split()),
        'processing_time': 'tracked_separately'
    }

def analyze_codebase(repo_path: Path, file_extensions: list[str] = ['.py', '.js']) -> str:
    """
    Load entire codebase into context for comprehensive analysis.
    Useful for repos up to ~100K tokens (substantial medium-sized projects).
    """
    code_context = ""

    for ext in file_extensions:
        files = list(repo_path.rglob(f'*{ext}'))
        for file_path in files:
            relative_path = file_path.relative_to(repo_path)
            with open(file_path, 'r', encoding='utf-8') as f:
                code = f.read()
                code_context += f"\n\n=== {relative_path} ===\n\n{code}"

    analysis_prompt = f"""
    You are analyzing a complete codebase. All files are provided below.

    Provide:
    1. Architecture overview (how components interact)
    2. Data flow through the system
    3. Security concerns or vulnerabilities
    4. Code quality issues (coupling, complexity)
    5. Suggested refactoring opportunities

    Be specific with file names and line references where relevant.

    Complete Codebase:
    {code_context}
    """

    response = ollama.chat(
        model='gemma4:31b-it-q4_K_M',
        messages=[{
            'role': 'user',
            'content': analysis_prompt
        }]
    )

    return response['message']['content']

# Example: Analyze a Flask microservice
analysis = analyze_codebase(
    repo_path=Path("./my-microservice"),
    file_extensions=['.py', '.yaml', '.sql']
)

# Model comparison for 40K token document

# Q4_K_M quantization (recommended)
# - Memory: ~19GB
# - Quality: 95% of full precision
# - Speed: Fast inference

# Q5_K_M quantization
# - Memory: ~23GB
# - Quality: 98% of full precision
# - Speed: Moderate inference

# FP16 (full precision)
# - Memory: ~60GB
# - Quality: 100% baseline
# - Speed: Slower inference

def process_very_long_document(doc_path: Path, max_chunk_tokens: int = 30000):
    """
    For documents exceeding memory limits, use hierarchical summarization.
    """
    chunks = split_document_intelligently(doc_path, max_chunk_tokens)

    summaries = []
    for chunk in chunks:
        summary = ollama.chat(
            model='gemma4:31b-it-q4_K_M',
            messages=[{
                'role': 'user',
                'content': f'Summarize this section, preserving key details:\n\n{chunk}'
            }]
        )
        summaries.append(summary['message']['content'])

    # Final synthesis with all summaries in context
    final_analysis = ollama.chat(
        model='gemma4:31b-it-q4_K_M',
        messages=[{
            'role': 'user',
            'content': f'Synthesize these summaries:\n\n' + '\n\n'.join(summaries)
        }]
    )

    return final_analysis['message']['content']

# Example: Structured context for better attention
structured_prompt = f"""
<documents>
  <document id="contract_msa">
    {msa_text}
  </document>

  <document id="contract_dpa">
    {dpa_text}
  </document>
</documents>

<query>
Compare data retention requirements between document "contract_msa" and "contract_dpa".
Cite specific sections from each.
</query>
"""

# Preload model with context that doesn't change
base_context = load_standard_documents()

# Ollama keeps context in memory for subsequent requests
ollama.chat(
    model='gemma4:31b-it-q4_K_M',
    messages=[{
        'role': 'system',
        'content': base_context
    }]
)

# Later queries reuse cached context (much faster)
for query in user_queries:
    response = ollama.chat(
        model='gemma4:31b-it-q4_K_M',
        messages=[
            {'role': 'system', 'content': base_context},
            {'role': 'user', 'content': query}
        ]
    )

def batch_analyze_documents(doc_paths: list[Path], queries: list[str]):
    """
    Load document once, run multiple queries.
    Amortizes context processing cost.
    """
    full_text = combine_documents(doc_paths)

    results = []
    for query in queries:
        response = ollama.chat(
            model='gemma4:31b-it-q4_K_M',
            messages=[{
                'role': 'user',
                'content': f'{full_text}\n\nQuery: {query}'
            }]
        )
        results.append(response['message']['content'])

    return results

def comprehensive_document_analysis(doc_path: Path) -> dict:
    """
    Multi-stage analysis leveraging full context at each stage.
    """
    full_text = extract_text_from_pdf(doc_path)

    # Stage 1: Structural analysis
    structure = ollama.chat(
        model='gemma4:31b-it-q4_K_M',
        messages=[{
            'role': 'user',
            'content': f'Outline the document structure:\n\n{full_text}'
        }]
    )

    # Stage 2: Key claims extraction
    claims = ollama.chat(
        model='gemma4:31b-it-q4_K_M',
        messages=[{
            'role': 'user',
            'content': f'List all factual claims made:\n\n{full_text}'
        }]
    )

    # Stage 3: Critical analysis (uses results from stage 2)
    analysis = ollama.chat(
        model='gemma4:31b-it-q4_K_M',
        messages=[{
            'role': 'user',
            'content': f'''
            Document: {full_text}

            Identified Claims: {claims['message']['content']}

            For each claim, assess:
            1. Supporting evidence in document
            2. Logical consistency
            3. Potential counterarguments
            '''
        }]
    )

    return {
        'structure': structure['message']['content'],
        'claims': claims['message']['content'],
        'critical_analysis': analysis['message']['content']
    }

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull Gemma 4 31B (recommended for long context)
ollama pull gemma4:31b-it-q4_K_M

# Verify installation
ollama run gemma4:31b-it-q4_K_M "Hello! Can you handle long contexts?"

pip install ollama PyPDF2

import ollama

# Test with a long prompt
long_text = "Lorem ipsum..." * 1000  # ~10K tokens

response = ollama.chat(
    model='gemma4:31b-it-q4_K_M',
    messages=[{
        'role': 'user',
        'content': f'Summarize the main themes:\n\n{long_text}'
    }]
)

print(f"Response: {response['message']['content']}")