def classify_content(content_type, audience, volume, deadline_hours, compliance_required):
    # Tier 3: Mission-critical
    if compliance_required or audience == 'external_legal':
        return 'strategic'

    if audience in ['public', 'customers', 'investors'] and content_type in ['marketing', 'contracts']:
        return 'strategic'

    # Tier 1: High-volume, low-risk
    if volume > 10000 and deadline_hours < 48:
        return 'mt_plus_review'

    if content_type in ['catalog', 'faq', 'reference'] and audience == 'internal':
        return 'mt_plus_review'

    # Tier 2: Standard
    return 'standard'

# Example usage
tier = classify_content(
    content_type='user_manual',
    audience='customers', 
    volume=5000,
    deadline_hours=120,
    compliance_required=True
)
print(tier)  # 'strategic'

import asyncio
from datetime import datetime, timedelta

class TranslationRouter:
    def __init__(self):
        self.mt_service = MTService()  # Your MT API
        self.human_service = HumanTranslationAPI()  # Professional service
        self.quality_checker = QualityAssurance()

    async def process_document(self, doc):
        tier = self.classify_document(doc)

        if tier == 'mt_plus_review':
            return await self.mt_with_selective_review(doc)
        elif tier == 'standard':
            return await self.standard_human_workflow(doc)
        else:  # strategic
            return await self.certified_workflow(doc)

    async def mt_with_selective_review(self, doc):
        # Machine translate everything
        mt_result = await self.mt_service.translate(doc)

        # Flag uncertain segments for human review
        uncertain_segments = self.quality_checker.flag_uncertain(
            mt_result, confidence_threshold=0.8
        )

        if uncertain_segments:
            reviewed_segments = await self.human_service.review_segments(
                uncertain_segments
            )
            mt_result.update(reviewed_segments)

        return mt_result

class QualityAssurance:
    def __init__(self):
        self.terminology_db = TerminologyDatabase()
        self.style_guide = StyleGuideChecker()

    def flag_uncertain(self, translation, confidence_threshold=0.8):
        flags = []

        for segment in translation.segments:
            # Low MT confidence
            if segment.confidence < confidence_threshold:
                flags.append(segment)

            # Technical terms
            if self.contains_technical_terms(segment.source):
                flags.append(segment)

            # Legal/compliance language
            if self.contains_legal_language(segment.source):
                flags.append(segment)

        return flags

    def contains_technical_terms(self, text):
        technical_patterns = ['API', 'OAuth', 'JWT', 'SSL/TLS']
        return any(term in text for term in technical_patterns)

    def contains_legal_language(self, text):
        legal_patterns = ['shall', 'whereas', 'hereby', 'notwithstanding']
        return any(term.lower() in text.lower() for term in legal_patterns)

class TranslationMemoryManager:
    def __init__(self):
        self.tm_database = TMDatabase()
        self.glossaries = GlossaryManager()

    def get_matches(self, segment, quality_tier):
        matches = self.tm_database.fuzzy_match(segment)

        # Higher tiers require higher match thresholds
        thresholds = {
            'mt_plus_review': 0.75,
            'standard': 0.85,
            'strategic': 0.95
        }

        return [m for m in matches if m.score >= thresholds[quality_tier]]

    def update_memory(self, source, target, quality_tier):
        # Only store high-quality translations
        if quality_tier in ['standard', 'strategic']:
            self.tm_database.store(source, target, tier=quality_tier)

class TranslationMetrics:
    def __init__(self):
        self.metrics = defaultdict(list)

    def log_translation(self, tier, word_count, cost, quality_score, delivery_time):
        self.metrics[tier].append({
            'words': word_count,
            'cost_per_word': cost / word_count,
            'quality': quality_score,
            'delivery_hours': delivery_time
        })

    def optimize_tier_assignment(self):
        # Analyze if content could move to lower-cost tiers
        for tier_data in self.metrics['strategic']:
            if tier_data['quality'] > 0.99 and tier_data['delivery_hours'] > 72:
                print(f"Consider moving to standard tier: {tier_data}")