{
  "response_type": "multi_select",
  "response_config": {
    "options": [
      {"value": "pii", "label": "🔒 Contains Personal Information"},
      {"value": "external_links", "label": "🔗 Includes External Links"},
      {"value": "promo", "label": "📢 Has Promotional Content"}
    ],
    "max_selections": 3
  }
}

def handle_moderation_decision(response_data):
    violations = response_data["selected_values"]
    labels = response_data["selected_labels"]
    
    # Check if content was approved
    if "content_approved" in violations:
        approve_content()
        log_decision("approved", labels)
        return
    
    # Process each violation type
    violation_actions = {
        "harassment": lambda: [remove_content(), warn_user(), log_violation("harassment")],
        "hate_speech": lambda: [remove_content(), suspend_user(days=7), log_violation("hate_speech")],
        "misinformation": lambda: [remove_content(), add_fact_check_label(), log_violation("misinformation")], 
        "adult_content": lambda: [remove_content(), age_restrict_user(), log_violation("adult_content")],
        "violence": lambda: [remove_content(), escalate_to_safety_team(), log_violation("violence")],
        "spam_promotion": lambda: [remove_content(), limit_posting(), log_violation("spam")],
        "copyright": lambda: [remove_content(), notify_copyright_team(), log_violation("copyright")]
    }
    
    # Execute actions for each violation
    for violation in violations:
        if violation in violation_actions:
            actions = violation_actions[violation]()
            execute_actions(actions)
    
    # Determine overall severity
    severe_violations = ["hate_speech", "violence", "harassment"]
    if any(v in violations for v in severe_violations):
        escalate_to_senior_moderator()
    
    # Log complete decision
    log_moderation_decision(violations, labels)

def handle_qa_checklist(response_data):
    passed_checks = response_data["selected_values"]
    labels = response_data["selected_labels"]
    
    # Define all possible checks
    all_checks = [
        "grammar_correct", "facts_accurate", "sources_cited", 
        "formatting_consistent", "images_optimized", "seo_compliant",
        "links_functional", "mobile_responsive"
    ]
    
    # Calculate completion score
    completion_score = len(passed_checks) / len(all_checks)
    failed_checks = [check for check in all_checks if check not in passed_checks]
    
    # Determine next steps based on completion
    if completion_score >= 0.9:
        # 90%+ pass rate - approve for publication
        approve_for_publication()
        log_qa_result("approved", completion_score, passed_checks)
        
    elif completion_score >= 0.7:
        # 70-89% pass rate - minor revisions needed
        request_minor_revisions(failed_checks)
        set_status("revision_required")
        log_qa_result("minor_revisions", completion_score, failed_checks)
        
    elif completion_score >= 0.5:
        # 50-69% pass rate - major revisions needed  
        request_major_revisions(failed_checks)
        set_status("major_revision_required")
        log_qa_result("major_revisions", completion_score, failed_checks)
        
    else:
        # <50% pass rate - reject and restart
        reject_submission()
        set_status("rejected")
        log_qa_result("rejected", completion_score, failed_checks)
    
    # Create specific action items
    create_action_items_for_failed_checks(failed_checks)
    
    # Notify stakeholders
    notify_qa_completion(completion_score, passed_checks, failed_checks)

def analyze_feature_request(response_data):
    positive_factors = response_data["selected_values"]
    labels = response_data["selected_labels"]
    
    # Weight different factors
    factor_weights = {
        "high_user_demand": 3,
        "strategic_value": 3,
        "technical_feasible": 2,
        "resource_available": 2,
        "competitive_advantage": 2,
        "low_maintenance": 1,
        "security_compliant": 2,
        "scalability_ready": 1
    }
    
    # Calculate weighted score
    total_score = sum(factor_weights[factor] for factor in positive_factors)
    max_possible_score = sum(factor_weights.values())
    priority_score = total_score / max_possible_score
    
    # Determine priority level
    if priority_score >= 0.8:
        priority = "P0 - Critical"
        next_action = "schedule_for_next_sprint"
    elif priority_score >= 0.6:
        priority = "P1 - High"
        next_action = "add_to_product_backlog_top"
    elif priority_score >= 0.4:
        priority = "P2 - Medium" 
        next_action = "add_to_product_backlog"
    else:
        priority = "P3 - Low"
        next_action = "consider_for_future_roadmap"
    
    # Check for critical requirements
    must_haves = ["technical_feasible", "security_compliant"]
    missing_requirements = [req for req in must_haves if req not in positive_factors]
    
    if missing_requirements:
        priority = "BLOCKED"
        next_action = "address_blockers_first"
    
    # Log analysis results
    log_feature_analysis({
        "priority_score": priority_score,
        "priority_level": priority,
        "positive_factors": positive_factors,
        "missing_requirements": missing_requirements,
        "recommended_action": next_action
    })
    
    # Execute next action
    execute_feature_decision(next_action, positive_factors)
    
    return {
        "priority": priority,
        "score": priority_score,
        "factors": labels,
        "action": next_action
    }