```python
#!/usr/bin/env python3
"""
Automated Nailfold Capillaroscopy Pattern Classification for Scleroderma Spectrum Disorders
Claw4S Skill — DNAI-ClinicalAI

Classifies nailfold capillaroscopy images into Cutolo patterns (Early/Active/Late)
with quantitative capillary density and morphology metrics.
"""

import numpy as np
from dataclasses import dataclass
from enum import Enum
from typing import List, Tuple, Dict
import json, sys

class CutoloPattern(Enum):
    EARLY = "Early"
    ACTIVE = "Active"
    LATE = "Late"

@dataclass
class CapillaryMetrics:
    density_per_mm: float        # Normal: 9-14/mm
    mean_width_um: float         # Normal: 10-15 μm, giant: >50 μm
    giant_count: int             # Capillaries >50 μm width
    hemorrhage_count: int        # Pericapillary hemorrhages
    avascular_score: float       # 0-3 scale (0=none, 3=desert)
    ramified_count: int          # Bushy/branching capillaries
    tortuosity_index: float      # Mean tortuosity (1.0=straight)

    def to_feature_vector(self) -> np.ndarray:
        return np.array([self.density_per_mm, self.mean_width_um, self.giant_count,
                         self.hemorrhage_count, self.avascular_score, self.ramified_count,
                         self.tortuosity_index])

# --- Synthetic capillaroscopy pattern generator ---
def generate_synthetic_capillary_field(pattern: CutoloPattern, rng=None) -> dict:
    """Generate synthetic capillary morphology data for a given Cutolo pattern."""
    if rng is None:
        rng = np.random.default_rng()

    params = {
        CutoloPattern.EARLY: dict(
            density=(10, 1.5), width=(18, 5), giants=(1, 1),
            hemorrhages=(0, 0.5), avascular=(0.2, 0.2), ramified=(0, 0.3), tortuosity=(1.2, 0.15)),
        CutoloPattern.ACTIVE: dict(
            density=(7, 1.5), width=(30, 8), giants=(5, 2),
            hemorrhages=(3, 1.5), avascular=(1.5, 0.5), ramified=(1, 1), tortuosity=(1.5, 0.2)),
        CutoloPattern.LATE: dict(
            density=(4, 1.5), width=(22, 6), giants=(1, 1),
            hemorrhages=(1, 1), avascular=(2.5, 0.4), ramified=(5, 2), tortuosity=(1.8, 0.3)),
    }
    p = params[pattern]
    return {
        "density_per_mm": max(0.5, rng.normal(*p["density"])),
        "mean_width_um": max(8, rng.normal(*p["width"])),
        "giant_count": max(0, int(rng.normal(*p["giants"]))),
        "hemorrhage_count": max(0, int(rng.normal(*p["hemorrhages"]))),
        "avascular_score": np.clip(rng.normal(*p["avascular"]), 0, 3),
        "ramified_count": max(0, int(rng.normal(*p["ramified"]))),
        "tortuosity_index": max(1.0, rng.normal(*p["tortuosity"])),
    }

# --- Image processing pipeline (skeleton — real impl uses opencv/skimage) ---
def segment_capillaries(image_array: np.ndarray) -> dict:
    """
    Skeleton: In production, applies:
    1. Green channel extraction (best contrast for capillaries)
    2. CLAHE enhancement
    3. Gabor filter bank for vessel detection
    4. Morphological skeletonization
    5. Connected component analysis for individual capillaries
    """
    # For demo, return synthetic metrics
    rng = np.random.default_rng(hash(image_array.tobytes()) % 2**32 if image_array.size < 1000 else 42)
    pattern = rng.choice(list(CutoloPattern))
    return generate_synthetic_capillary_field(pattern, rng)

# --- Random Forest Classifier (trained on synthetic data) ---
class CapillaroscopyClassifier:
    def __init__(self):
        self.rng = np.random.default_rng(42)
        self._train()

    def _train(self):
        """Train on synthetic dataset of 900 samples (300 per class)."""
        X, y = [], []
        for pattern in CutoloPattern:
            for _ in range(300):
                fields = generate_synthetic_capillary_field(pattern, self.rng)
                m = CapillaryMetrics(**fields)
                X.append(m.to_feature_vector())
                y.append(pattern.value)
        self.X_train = np.array(X)
        self.y_train = np.array(y)
        # Simple distance-based classifier (no sklearn dependency for portability)
        self.centroids = {}
        self.stds = {}
        for p in CutoloPattern:
            mask = self.y_train == p.value
            self.centroids[p.value] = self.X_train[mask].mean(axis=0)
            self.stds[p.value] = self.X_train[mask].std(axis=0) + 1e-6

    def predict(self, metrics: CapillaryMetrics) -> Tuple[CutoloPattern, Dict[str, float], float]:
        """Classify and return pattern, probabilities, and microangiopathy score (0-10)."""
        x = metrics.to_feature_vector()
        log_probs = {}
        for p in CutoloPattern:
            z = (x - self.centroids[p.value]) / self.stds[p.value]
            log_probs[p.value] = -0.5 * np.sum(z**2)

        max_lp = max(log_probs.values())
        probs = {k: np.exp(v - max_lp) for k, v in log_probs.items()}
        total = sum(probs.values())
        probs = {k: round(v / total, 4) for k, v in probs.items()}

        predicted = max(probs, key=probs.get)
        # Microangiopathy Evolution Score (MES): 0-10
        mes = (metrics.avascular_score / 3 * 4 +
               min(metrics.giant_count, 10) / 10 * 2 +
               min(metrics.hemorrhage_count, 8) / 8 * 1.5 +
               min(metrics.ramified_count, 8) / 8 * 1.5 +
               (1 - min(metrics.density_per_mm, 12) / 12) * 1)
        return CutoloPattern(predicted), probs, round(min(mes, 10), 2)

# --- Drug response tracking ---
def track_treatment_response(serial_metrics: List[CapillaryMetrics]) -> dict:
    """Analyze serial capillaroscopy for treatment response."""
    clf = CapillaroscopyClassifier()
    results = []
    for i, m in enumerate(serial_metrics):
        pattern, probs, mes = clf.predict(m)
        results.append({"visit": i+1, "pattern": pattern.value, "MES": mes,
                        "density": round(m.density_per_mm, 1), "giants": m.giant_count,
                        "avascular": round(m.avascular_score, 2)})
    if len(results) >= 2:
        delta_mes = results[-1]["MES"] - results[0]["MES"]
        trend = "improving" if delta_mes < -0.5 else "worsening" if delta_mes > 0.5 else "stable"
    else:
        trend = "insufficient data"
    return {"visits": results, "trend": trend,
            "delta_MES": round(results[-1]["MES"] - results[0]["MES"], 2) if len(results) >= 2 else None}

# --- Demo ---
def main():
    print("=" * 70)
    print("NAILFOLD CAPILLAROSCOPY PATTERN CLASSIFIER — Claw4S Skill")
    print("=" * 70)

    clf = CapillaroscopyClassifier()
    rng = np.random.default_rng(123)

    for pattern in CutoloPattern:
        print(f"\n--- Synthetic {pattern.value} Pattern ---")
        fields = generate_synthetic_capillary_field(pattern, rng)
        m = CapillaryMetrics(**fields)
        predicted, probs, mes = clf.predict(m)
        print(f"  Density: {m.density_per_mm:.1f}/mm | Width: {m.mean_width_um:.1f}μm | "
              f"Giants: {m.giant_count} | Hemorrhages: {m.hemorrhage_count}")
        print(f"  Avascular: {m.avascular_score:.2f}/3 | Ramified: {m.ramified_count} | "
              f"Tortuosity: {m.tortuosity_index:.2f}")
        print(f"  → Predicted: {predicted.value} | MES: {mes}/10")
        print(f"  → Probabilities: {probs}")

    # Treatment tracking demo
    print(f"\n{'=' * 70}")
    print("TREATMENT RESPONSE TRACKING (Iloprost therapy simulation)")
    print("=" * 70)
    serial = []
    for i in range(4):
        # Simulate improvement: Active → Early transition
        blend = max(0, 1 - i * 0.3)
        fields_active = generate_synthetic_capillary_field(CutoloPattern.ACTIVE, np.random.default_rng(i+10))
        fields_early = generate_synthetic_capillary_field(CutoloPattern.EARLY, np.random.default_rng(i+10))
        blended = {k: fields_active[k] * blend + fields_early[k] * (1 - blend) for k in fields_active}
        blended["giant_count"] = int(blended["giant_count"])
        blended["hemorrhage_count"] = int(blended["hemorrhage_count"])
        blended["ramified_count"] = int(blended["ramified_count"])
        serial.append(CapillaryMetrics(**blended))

    response = track_treatment_response(serial)
    for v in response["visits"]:
        print(f"  Visit {v['visit']}: {v['pattern']} (MES={v['MES']}) | density={v['density']}/mm, giants={v['giants']}")
    print(f"  Trend: {response['trend']} (ΔMES={response['delta_MES']})")

if __name__ == "__main__":
    main()

```