Credibility Scoring

function calculateSourceQuality(sources: Source[]): number {
  const uniqueDomains = new Set(
    sources.map(s => new URL(s.url).hostname)
  ).size;
  
  const trustedCount = sources.filter(s => 
    TRUSTED_OUTLETS.includes(new URL(s.url).hostname)
  ).length;
  
  let score = 0;
  
  if (sources.length >= 8 && uniqueDomains >= 7) score = 3.0;
  else if (sources.length >= 5 && uniqueDomains >= 4) score = 2.0;
  else if (sources.length >= 3) score = 1.0;
  else score = 0.5;
  
  // Bonus for trusted sources
  if (trustedCount / sources.length >= 0.5) score += 0.5;
  
  return Math.min(3.0, score);
}

function calculateEvidenceStrength(blueprint: ArgumentNode[]): number {
  const evidenceNodes = blueprint.filter(n => n.type === 'evidence');
  
  let strengthScore = 0;
  let totalWeight = 0;
  
  for (const evidence of evidenceNodes) {
    const type = classifyEvidence(evidence.content, evidence.source);
    
    switch (type) {
      case 'primary-research':
        strengthScore += 3.0;
        break;
      case 'expert-testimony':
        strengthScore += 2.0;
        break;
      case 'secondary-analysis':
        strengthScore += 1.0;
        break;
      case 'opinion':
      default:
        strengthScore += 0;
    }
    
    totalWeight += 1;
  }
  
  return totalWeight > 0 ? (strengthScore / totalWeight) : 0;
}

function classifyEvidence(content: string, source: string): string {
  const lowerContent = content.toLowerCase();
  const lowerSource = source.toLowerCase();
  
  // Check for research indicators
  if (
    lowerContent.includes('study found') ||
    lowerContent.includes('research shows') ||
    lowerSource.includes('nih.gov') ||
    lowerSource.includes('.edu') ||
    lowerSource.includes('nature.com')
  ) {
    return 'primary-research';
  }
  
  // Check for expert quotes
  if (
    lowerContent.includes('dr.') ||
    lowerContent.includes('professor') ||
    lowerContent.includes('expert')
  ) {
    return 'expert-testimony';
  }
  
  // Default to secondary
  return 'secondary-analysis';
}

function calculateFallacyPenalty(fallacies: DetectedFallacy[]): number {
  let totalPenalty = 0;
  
  for (const fallacy of fallacies) {
    let basePenalty = 0;
    
    switch (fallacy.severity) {
      case 'Critical':
        basePenalty = -1.0;
        break;
      case 'Major':
        basePenalty = -0.5;
        break;
      case 'Minor':
        basePenalty = -0.2;
        break;
    }
    
    // Weight by confidence
    const confidenceMultiplier = fallacy.confidence;
    totalPenalty += basePenalty * confidenceMultiplier;
  }
  
  // Cap maximum penalty
  return Math.max(-3.0, totalPenalty);
}

function calculateLogicalCoherence(blueprint: ArgumentNode[]): number {
  let score = 1.0; // Start at max
  
  const claims = blueprint.filter(n => 
    n.type === 'claim' || n.type === 'counterclaim'
  );
  
  const evidence = blueprint.filter(n => n.type === 'evidence');
  
  // Penalty for claims without evidence
  const orphanedClaims = claims.filter(
    c => !evidence.some(e => e.parentId === c.id)
  );
  
  if (orphanedClaims.length > claims.length * 0.3) {
    score -= 0.3; // More than 30% orphaned
  }
  
  // Penalty for one-sided analysis
  const forClaims = claims.filter(c => c.side === 'for');
  const againstClaims = claims.filter(c => c.side === 'against');
  
  const ratio = Math.min(forClaims.length, againstClaims.length) / 
                Math.max(forClaims.length, againstClaims.length);
  
  if (ratio < 0.3) {
    score -= 0.4; // Very one-sided
  }
  
  return Math.max(0, score);
}