curl -X GET "https://api.omophub.com/v1/mappings/quality/SNOMED/ICD10CM" \
  -H "Authorization: Bearer YOUR_API_KEY"

curl -X GET "https://api.omophub.com/v1/mappings/quality/SNOMED/ICD10CM?vocab_release=2025.1" \
  -H "Authorization: Bearer YOUR_API_KEY"

import { OMOPHub } from '@omophub/omophub-node';

// Not yet exposed as a dedicated SDK method — use the typed low-level helper.
const client = new OMOPHub();

interface QualityResult {
  quality_overview: {
    total_mappings_analyzed: number;
    overall_quality_rating: string;
    overall_average_confidence: number;
    high_quality_percentage: number;
    validated_percentage: number;
  };
  quality_by_domain: Record<string, {
    domain_name: string;
    average_confidence: number;
    total_mappings: number;
    quality_distribution: { excellent: number; good: number; moderate: number; poor: number };
  }>;
}

const { data } = await client.get<QualityResult>('/mappings/quality/SNOMED/ICD10CM');

if (data) {
  const { quality_overview, quality_by_domain } = data;

  console.log('=== Mapping Quality Analysis ===');
  console.log(`Total mappings analyzed: ${quality_overview.total_mappings_analyzed.toLocaleString()}`);
  console.log(`Overall quality rating: ${quality_overview.overall_quality_rating}`);
  console.log(`Average confidence: ${(quality_overview.overall_average_confidence * 100).toFixed(1)}%`);
  console.log(`High-quality: ${quality_overview.high_quality_percentage.toFixed(1)}%`);
  console.log(`Validated: ${quality_overview.validated_percentage.toFixed(1)}%`);

  console.log('\n=== Quality by Domain ===');
  for (const [, domainData] of Object.entries(quality_by_domain)) {
    const dist = domainData.quality_distribution;
    console.log(`${domainData.domain_name}: ${(domainData.average_confidence * 100).toFixed(1)}% avg, ${domainData.total_mappings.toLocaleString()} mappings`);
    console.log(`  Distribution: ${dist.excellent.toLocaleString()} excellent / ${dist.good.toLocaleString()} good / ${dist.moderate.toLocaleString()} moderate / ${dist.poor.toLocaleString()} poor`);
  }
}

import requests

source_vocab = "SNOMED"
target_vocab = "ICD10CM"
url = f"https://api.omophub.com/v1/mappings/quality/{source_vocab}/{target_vocab}"

headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}

response = requests.get(url, headers=headers)
data = response.json()

print("=== MAPPING QUALITY ANALYSIS ===")
overview = data['data']['quality_overview']
print(f"Total mappings analyzed: {overview['total_mappings_analyzed']:,}")
print(f"Overall quality rating: {overview['overall_quality_rating']}")
print(f"Average confidence: {overview['overall_average_confidence']:.3f}")
print(f"High-quality mappings: {overview['high_quality_percentage']:.1f}%")
print(f"Validated mappings: {overview['validated_percentage']:.1f}%")
print(f"Disputed mappings: {overview['disputed_percentage']:.1f}%")

# Domain quality analysis
print(f"\n=== QUALITY BY DOMAIN ===")
domain_quality = data['data']['quality_by_domain']
domain_df = pd.DataFrame([
    {
        'domain': info['domain_name'],
        'total_mappings': info['total_mappings'],
        'avg_confidence': info['average_confidence'],
        'excellent': info['quality_distribution']['excellent'],
        'good': info['quality_distribution']['good'],
        'moderate': info['quality_distribution']['moderate'],
        'poor': info['quality_distribution']['poor']
    }
    for domain_id, info in domain_quality.items()
])

domain_df = domain_df.sort_values('avg_confidence', ascending=False)
print(domain_df.to_string(index=False, float_format='%.3f'))

# Vocabulary pair quality analysis
print(f"\n=== VOCABULARY PAIR QUALITY ===")
vocab_pairs = []
for source_vocab, source_data in data['data']['quality_by_vocabulary_pair'].items():
    for target_vocab, pair_data in source_data['target_vocabularies'].items():
        vocab_pairs.append({
            'source': source_vocab,
            'target': target_vocab,
            'pair': f"{source_vocab} → {target_vocab}",
            'avg_confidence': pair_data['average_confidence'],
            'total_mappings': pair_data['total_mappings'],
            'validation_rate': pair_data['validation_rate'],
            'quality_rating': pair_data['quality_rating']
        })

vocab_pair_df = pd.DataFrame(vocab_pairs)
vocab_pair_df = vocab_pair_df.sort_values('avg_confidence', ascending=False)

print("Top 10 Quality Vocabulary Pairs:")
top_pairs = vocab_pair_df.head(10)
for _, row in top_pairs.iterrows():
    print(f"{row['pair']}: {row['avg_confidence']:.3f} confidence, {row['total_mappings']:,} mappings ({row['quality_rating']})")

print("\nBottom 5 Quality Vocabulary Pairs:")
bottom_pairs = vocab_pair_df.tail(5)
for _, row in bottom_pairs.iterrows():
    print(f"{row['pair']}: {row['avg_confidence']:.3f} confidence, {row['total_mappings']:,} mappings ({row['quality_rating']})")

# Quality metrics analysis
if 'quality_metrics' in data['data']:
    metrics = data['data']['quality_metrics']
    print(f"\n=== DETAILED QUALITY METRICS ===")
    
    # Confidence distribution
    if 'confidence_score_distribution' in metrics:
        conf_dist = metrics['confidence_score_distribution']
        print(f"Confidence Score Statistics:")
        if 'percentiles' in conf_dist:
            for percentile, value in conf_dist['percentiles'].items():
                print(f"  {percentile}th percentile: {value:.3f}")
        
        if 'skewness' in conf_dist:
            print(f"  Skewness: {conf_dist['skewness']:.3f}")
        if 'kurtosis' in conf_dist:
            print(f"  Kurtosis: {conf_dist['kurtosis']:.3f}")
    
    # Semantic similarity analysis
    if 'semantic_similarity_analysis' in metrics:
        sem_analysis = metrics['semantic_similarity_analysis']
        print(f"\nSemantic Similarity Analysis:")
        print(f"  Average similarity: {sem_analysis['average_similarity']:.3f}")
        print(f"  Similarity-confidence correlation: {sem_analysis['similarity_confidence_correlation']:.3f}")
        print(f"  Low similarity, high confidence: {sem_analysis['low_similarity_high_confidence']:,}")
        print(f"  High similarity, low confidence: {sem_analysis['high_similarity_low_confidence']:,}")
    
    # Mapping source analysis
    if 'mapping_source_analysis' in metrics:
        source_analysis = metrics['mapping_source_analysis']
        print(f"\nQuality by Mapping Source:")
        for source, source_data in source_analysis.items():
            if 'average_confidence' in source_data:
                print(f"  {source}: {source_data['average_confidence']:.3f} avg confidence")

# Outlier analysis
if 'quality_outliers' in data['data']:
    outliers = data['data']['quality_outliers']
    print(f"\n=== QUALITY OUTLIERS ===")
    
    if outliers.get('low_quality_outliers'):
        print(f"Low Quality Outliers ({len(outliers['low_quality_outliers'])}):")
        for outlier in outliers['low_quality_outliers'][:5]:
            print(f"  Concepts {outlier['source_concept_id']} → {outlier['target_concept_id']}")
            print(f"    Confidence: {outlier['confidence_score']:.3f}")
            print(f"    Reason: {outlier['outlier_reason']}")
    
    if outliers.get('outlier_patterns'):
        print(f"\nCommon Outlier Patterns:")
        for pattern in outliers['outlier_patterns'][:3]:
            print(f"  - {pattern}")

# Trends analysis
if 'quality_trends' in data['data']:
    trends = data['data']['quality_trends']
    print(f"\n=== QUALITY TRENDS ===")
    print(f"Quality improvement rate: {trends['quality_improvement_rate']:.2f}% annually")
    
    if trends.get('fastest_improving_areas'):
        print(f"Fastest improving areas:")
        for area in trends['fastest_improving_areas'][:3]:
            print(f"  - {area}")
    
    # Plot quality trend
    if trends.get('quality_over_time'):
        quality_history = trends['quality_over_time']
        dates = [point['date'] for point in quality_history]
        confidences = [point['average_confidence'] for point in quality_history]
        validation_rates = [point['validation_rate'] for point in quality_history]
        
        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))
        
        # Confidence trend
        ax1.plot(dates, confidences, marker='o', linewidth=2)
        ax1.set_title('Average Confidence Score Over Time')
        ax1.set_ylabel('Confidence Score')
        ax1.tick_params(axis='x', rotation=45)
        ax1.grid(True, alpha=0.3)
        
        # Validation rate trend
        ax2.plot(dates, validation_rates, marker='s', linewidth=2, color='green')
        ax2.set_title('Validation Rate Over Time')
        ax2.set_xlabel('Date')
        ax2.set_ylabel('Validation Rate')
        ax2.tick_params(axis='x', rotation=45)
        ax2.grid(True, alpha=0.3)
        
        plt.tight_layout()
        plt.show()

# Recommendations
if 'recommendations' in data['data']:
    print(f"\n=== QUALITY IMPROVEMENT RECOMMENDATIONS ===")
    recommendations = data['data']['recommendations']
    for i, rec in enumerate(recommendations[:7], 1):
        print(f"{i}. {rec['title']} ({rec['priority']} Priority)")
        print(f"   {rec['description']}")
        print(f"   Expected improvement: {rec['expected_improvement']}")
        print(f"   Implementation effort: {rec['implementation_effort']}")
        if rec.get('affected_vocabulary_pairs'):
            print(f"   Affects: {', '.join(rec['affected_vocabulary_pairs'][:3])}")
        print()

# Create comprehensive quality dashboard
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(16, 12))

# 1. Domain quality comparison
domain_names = domain_df['domain']
domain_confidences = domain_df['avg_confidence']
ax1.barh(domain_names, domain_confidences, color='skyblue')
ax1.set_xlabel('Average Confidence Score')
ax1.set_title('Quality by Medical Domain')
ax1.set_xlim(0, 1)

# 2. Quality distribution pie chart
quality_counts = [
    domain_df['excellent'].sum(),
    domain_df['good'].sum(),
    domain_df['moderate'].sum(),
    domain_df['poor'].sum()
]
quality_labels = ['Excellent', 'Good', 'Moderate', 'Poor']
colors = ['#2ecc71', '#3498db', '#f39c12', '#e74c3c']
ax2.pie(quality_counts, labels=quality_labels, colors=colors, autopct='%1.1f%%')
ax2.set_title('Overall Quality Distribution')

# 3. Vocabulary pair quality heatmap
if len(vocab_pair_df) > 0:
    # Create pivot table for heatmap
    pivot_data = vocab_pair_df.pivot_table(
        values='avg_confidence', 
        index='source', 
        columns='target',
        fill_value=0
    )
    
    sns.heatmap(pivot_data, annot=True, fmt='.2f', cmap='RdYlGn', ax=ax3)
    ax3.set_title('Vocabulary Pair Quality Matrix')
    ax3.set_xlabel('Target Vocabulary')
    ax3.set_ylabel('Source Vocabulary')

# 4. Confidence score histogram
if 'quality_metrics' in data['data'] and 'confidence_score_distribution' in data['data']['quality_metrics']:
    conf_dist = data['data']['quality_metrics']['confidence_score_distribution']
    if 'histogram_bins' in conf_dist:
        bins = conf_dist['histogram_bins']
        bin_centers = [(bin['min'] + bin['max']) / 2 for bin in bins]
        bin_counts = [bin['count'] for bin in bins]
        
        ax4.bar(bin_centers, bin_counts, width=0.05, alpha=0.7, color='lightcoral')
        ax4.set_xlabel('Confidence Score')
        ax4.set_ylabel('Number of Mappings')
        ax4.set_title('Confidence Score Distribution')
        ax4.set_xlim(0, 1)

plt.tight_layout()
plt.show()

# Summary report
print(f"\n=== SUMMARY REPORT ===")
print(f"• Analyzed {overview['total_mappings_analyzed']:,} mappings across {len(domain_quality)} domains")
print(f"• Overall system quality rating: {overview['overall_quality_rating'].upper()}")
print(f"• {overview['high_quality_percentage']:.1f}% of mappings are high-quality (confidence > 0.8)")
print(f"• {overview['validated_percentage']:.1f}% of mappings are officially validated")
print(f"• Top quality domain: {domain_df.iloc[0]['domain']} ({domain_df.iloc[0]['avg_confidence']:.3f} avg confidence)")
print(f"• Best vocabulary pair: {vocab_pair_df.iloc[0]['pair']} ({vocab_pair_df.iloc[0]['avg_confidence']:.3f} confidence)")

if 'recommendations' in data['data']:
    high_priority_recs = [r for r in data['data']['recommendations'] if r['priority'] == 'high']
    print(f"• {len(high_priority_recs)} high-priority improvement recommendations identified")