from honeybee import HoneyBee

hb = HoneyBee()

clinical_note = """Patient: Jane Doe, 58-year-old postmenopausal female.
Date of Visit: 03/15/2024

History of Present Illness:
Patient was diagnosed with invasive ductal carcinoma of the left breast on 01/10/2024
following an abnormal screening mammogram on 12/05/2023. Core needle biopsy confirmed
Grade 2 moderately differentiated adenocarcinoma. Tumor measures 2.3 cm on imaging.

Biomarker Profile:
ER: positive (95%), PR: positive (80%), HER2: negative (IHC 1+), Ki-67: 22%.

Medications:
Tamoxifen 20 mg daily, Metformin 1000 mg bid, Lisinopril 10 mg daily.

Plan: Begin dose-dense AC-T (doxorubicin/cyclophosphamide x4 followed by
paclitaxel x4) starting 04/01/2024.
"""

result = hb.process_clinical(text=clinical_note)

print(f"Entities:      {len(result.entities)}")
print(f"Relationships: {len(result.relationships)}")
print(f"Timeline:      {len(result.timeline)} events")

from huggingface_hub import hf_hub_download

# Download sample clinical PDF from HuggingFace
pdf_path = hf_hub_download(
    repo_id="Lab-Rasool/honeybee-samples",
    filename="sample.PDF",
    repo_type="dataset",
)
print(f"Downloaded: {pdf_path}")

# Process the PDF through the full clinical pipeline
pdf_result = hb.process_clinical(document_path=pdf_path)

# Show extraction metadata
meta = pdf_result.document.metadata
print(f"Extraction method: {meta.get('extraction_method', 'unknown')}")
print(f"Pages: {meta.get('num_pages', 'N/A')}")
print(f"Text length: {len(pdf_result.document.text):,} chars")
print(f"Entities: {len(pdf_result.entities)}")
print(f"Relationships: {len(pdf_result.relationships)}")

from collections import Counter

entities = result.entities
type_counts = Counter(e.type for e in entities)

# Show entity type distribution
for etype, count in type_counts.most_common():
    print(f"  {etype:<14s}: {count}")

# Top-15 entities
print(f"\n{'Text':>35s}  {'Type':<12s}  {'Conf':>5s}")
print("-" * 58)
for e in entities[:15]:
    print(f"{e.text[:35]:>35s}  {e.type:<12s}  {e.confidence:>5.2f}")

# Define oncology keyword categories
CANCER_KEYWORDS = {
    "tumor": ["carcinoma", "adenocarcinoma", "cancer", "tumor",
              "ductal", "invasive", "glioblastoma"],
    "biomarker": ["ER", "PR", "HER2", "Ki-67", "EGFR", "ALK",
                  "PD-L1", "Oncotype", "GFAP", "MIB-1"],
    "staging": ["T2N1M0", "Stage", "Grade", "metastasis"],
    "treatment": ["doxorubicin", "cyclophosphamide", "paclitaxel",
                  "tamoxifen", "pembrolizumab", "chemotherapy", "radiation"],
}

# Filter entities
print(f"{'Entity Text':>35s}  {'NER Type':<12s}  {'Onc. Category':<14s}")
print("-" * 65)
for e in entities:
    for cat, keywords in CANCER_KEYWORDS.items():
        if any(kw.lower() in e.text.lower() for kw in keywords):
            print(f"{e.text[:35]:>35s}  {e.type:<12s}  {cat:<14s}")
            break

# Default transformer backend — no context flags set
sample = entities[0]
print(f"Entity: {sample.text!r}")
print(f"  is_negated:    {sample.is_negated}")
print(f"  is_uncertain:  {sample.is_uncertain}")
print(f"  is_historical: {sample.is_historical}")
print(f"  is_family:     {sample.is_family}")

# Enable context detection with medspacy
hb = HoneyBee(config={"clinical": {"ner": {"backends": ["medspacy"]}}})

print(f"{'Source':>30s}  {'Relation':<18s}  Target")
print("-" * 80)
for rel in result.relationships[:12]:
    src = rel.get("source_text", entities[rel["source_idx"]].text)[:30]
    tgt = rel.get("target_text", entities[rel["target_idx"]].text)[:30]
    print(f"{src:>30s}  {rel['type']:<18s}  {tgt}")

timeline = result.timeline

print(f"{'Date Text':>15s}  {'Parsed':>12s}  Related Entities")
print("-" * 75)
for ev in timeline:
    related = [entities[i].text[:25] for i in ev.related_entities
               if i < len(entities)]
    label = ", ".join(related[:3])
    if len(related) > 3:
        label += f" (+{len(related) - 3})"
    print(f"{ev.date_text:>15s}  {str(ev.date)[:10]:>12s}  {label}")

import json

bundle = hb.clinical_processor.to_fhir(result, patient_id="patient-001")

entries = bundle.get("entry", [])
resource_types = Counter(e["resource"]["resourceType"] for e in entries)
print(f"Bundle: {bundle['resourceType']}  ({len(entries)} entries)")
for rtype, count in resource_types.most_common():
    print(f"  {rtype:<25s}: {count}")

print(f"\n--- Sample Condition resource ---")
print(json.dumps(entries[0]["resource"], indent=2))

# Re-process with Snowstorm ontology linking enabled
hb_onto = HoneyBee(config={"clinical": {"ontology": {"backends": ["snowstorm"]}}})
result_onto = hb_onto.process_clinical(text=clinical_note)

coded = [e for e in result_onto.entities if e.ontology_codes]

if coded:
    print(f"{'Entity':>30s}  {'System':<12s}  {'Code':<14s}  Display")
    print("-" * 90)
    for e in coded[:15]:
        oc = e.ontology_codes[0]
        print(f"{e.text[:30]:>30s}  {oc.system:<12s}  {oc.code:<14s}  {oc.display[:35]}")
    print(f"\n{len(coded)} / {len(result_onto.entities)} entities linked")
else:
    print("Snowstorm returned 0 codes (public server may be rate-limiting).")

hb = HoneyBee(config={"clinical": {"ontology": {
    "backends": ["snowstorm"],
    "snowstorm_base_url": "http://localhost:8080/snowstorm/snomed-ct",
}}})

import numpy as np

# Single model
emb = hb.generate_embeddings(clinical_note, modality="clinical",
                              model_name="bioclinicalbert")
print(f"bioclinicalbert: shape={emb.shape}, norm={np.linalg.norm(emb):.2f}")

# Multi-model comparison
for name in ["bioclinicalbert", "pubmedbert", "biobert", "scibert"]:
    e = hb.generate_embeddings(clinical_note, modality="clinical", model_name=name)
    print(f"{name:>20s}: shape={e.shape}, norm={np.linalg.norm(e):.2f}")

segments = [
    "invasive ductal carcinoma Grade 2",
    "breast cancer T2N1M0 Stage IIB",
    "ER positive PR positive HER2 negative",
    "tamoxifen 20 mg daily",
    "doxorubicin cyclophosphamide paclitaxel",
    "hemoglobin 11.2 albumin 3.8",
    "non-small cell lung cancer EGFR positive",
    "carboplatin paclitaxel pembrolizumab",
]

seg_emb = hb.generate_embeddings(segments, modality="clinical",
                                  model_name="bioclinicalbert")
norms = np.linalg.norm(seg_emb, axis=1, keepdims=True)
norms = np.where(norms == 0, 1, norms)
similarity = (seg_emb / norms) @ (seg_emb / norms).T

# Print top-5 most similar pairs (excluding self-similarity)
pairs = []
for i in range(len(segments)):
    for j in range(i + 1, len(segments)):
        pairs.append((similarity[i, j], segments[i][:30], segments[j][:30]))
pairs.sort(reverse=True)

print("Top-5 most similar segment pairs:")
for sim, a, b in pairs[:5]:
    print(f"  {sim:.3f}  {a}  <->  {b}")

comparison_note = """Patient: John Smith, 65-year-old male.
Diagnosed with stage IIIA non-small cell lung cancer (adenocarcinoma) on 06/15/2024.
EGFR: positive, ALK: negative, PD-L1: positive (75%).
Started on carboplatin 450 mg iv plus paclitaxel 200 mg iv q3w on 07/01/2024.
Pembrolizumab 200 mg iv q3w added as immunotherapy.
CT scan on 09/15/2024 showed partial response.
"""

result2 = hb.process_clinical(text=comparison_note)

# Side-by-side summary statistics
for label, r in [("Jane Doe (breast)", result), ("John Smith (lung)", result2)]:
    stats = hb.clinical_processor.get_summary_statistics(r)
    print(f"--- {label} ---")
    print(f"  Text length:    {stats['text_length']:,} chars")
    print(f"  Entities:       {stats['num_entities']}")
    print(f"  Entity types:   {dict(stats['entity_types'])}")
    print(f"  Relationships:  {stats['num_relationships']}")
    print(f"  Timeline:       {stats['num_timeline_events']} events")
    print()

import json

output = result.to_dict()

print("Top-level keys:", list(output.keys()))
print(f"  text:          {len(output['text']):,} chars")
print(f"  sections:      {len(output['sections'])} sections")
print(f"  metadata:      {output['metadata']}")
print(f"  entities:      {len(output['entities'])} items")
print(f"  relationships: {len(output['relationships'])} items")
print(f"  timeline:      {len(output['timeline'])} items")

{
  "text": "58-year-old",
  "type": "temporal",
  "start": 19,
  "end": 30,
  "confidence": 0.88,
  "properties": {
    "backend": "transformer",
    "label": "Age"
  },
  "is_negated": false,
  "is_uncertain": false,
  "is_historical": false,
  "is_family": false,
  "ontology_codes": []
}

{
  "date": "2023-12-05T00:00:00",
  "date_text": "12/05/2023",
  "sentence": "Patient was diagnosed with invasive ductal carcinoma...",
  "related_entities": [2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
}

clinical_emb = hb.generate_embeddings(clinical_note, modality="clinical",
                                       model_name="bioclinicalbert")
pathology_emb = np.random.randn(1, 1536)   # e.g., UNI2 output
radiology_emb = np.random.randn(1, 768)    # e.g., RAD-DINO output

integrated = hb.integrate_embeddings([clinical_emb, pathology_emb, radiology_emb])

print(f"Clinical:   {clinical_emb.shape}")
print(f"Pathology:  {pathology_emb.shape}")
print(f"Radiology:  {radiology_emb.shape}")
print(f"Integrated: {integrated.shape}")