src/multi_agent_training/specialized/generators/ethics_generator.py

"""
Ethics Module Synthetic Data Generator for MangoMAS Local

This module generates synthetic training data for the ethics capability.
"""

import json
import logging
import random
from pathlib import Path
from typing import Any, Dict, List

from ..synthetic_data_generator import (SyntheticDataGenerator,
                                        SyntheticDataGeneratorRegistry)

logger = logging.getLogger(__name__)

# Templates for ethics scenarios
ETHICAL_DOMAINS = [
    "privacy and data protection",
    "algorithmic fairness and bias",
    "transparency and explainability",
    "safety and risk management",
    "human autonomy and consent",
    "social impact and responsibility",
    "environmental sustainability",
    "intellectual property",
    "misinformation and content moderation",
    "inclusion and accessibility",
]

ETHICAL_PRINCIPLES = [
    "autonomy - respecting individual choice and self-determination",
    "beneficence - promoting well-being and preventing harm",
    "non-maleficence - avoiding causing harm",
    "justice - ensuring fair distribution of benefits and burdens",
    "transparency - being open about actions and decisions",
    "accountability - taking responsibility for outcomes",
    "privacy - protecting personal information",
    "consent - obtaining informed agreement",
    "dignity - respecting the inherent worth of individuals",
    "sustainability - meeting present needs without compromising future generations",
    "inclusivity - ensuring access and representation for all groups",
    "proportionality - ensuring actions are appropriate to circumstances",
]

SCENARIO_TEMPLATES = [
    "A company is developing {system_type} that collects {data_type} from users to {purpose}. However, there are concerns that {concern}.",
    "An organization wants to use {system_type} to {purpose} in {context}. Some stakeholders worry that {concern}.",
    "A research team has created {system_type} that can {capability}. While this could {benefit}, there's a risk that {risk}.",
    "A government agency plans to deploy {system_type} for {purpose} across {context}. Critics argue that {criticism}.",
    "A new {system_type} enables {capability}, promising to {benefit}. However, ethical questions arise when {ethical_question}.",
    "A multinational corporation is implementing {system_type} that will {capability} affecting {stakeholders}. This raises questions about {ethical_question}.",
    "An education institution is considering using {system_type} to {purpose} for students. Parents and educators are divided because {concern}.",
    "Healthcare providers are exploring {system_type} to {purpose} for patients. Medical ethicists caution that {caution}.",
    "A startup has developed {system_type} that can {capability}, potentially disrupting {industry}. This creates tension between {competing_values}.",
    "A social media platform is rolling out {system_type} to {purpose}. Civil liberties organizations are concerned that {concern}.",
]

ANALYSIS_TEMPLATES = [
    "From an ethical standpoint, this scenario involves several key principles. First, {principle_1} is at stake because {principle_1_reason}. Second, {principle_2} must be considered as {principle_2_reason}. There's also a tension between {competing_value_1} and {competing_value_2}, as {tension_explanation}. Looking at potential consequences, {consequence_1} could result if {condition_1}, while {consequence_2} might occur if {condition_2}. Stakeholder perspectives vary: {stakeholder_1} would prioritize {priority_1}, whereas {stakeholder_2} would emphasize {priority_2}.",
    "This ethical dilemma centers on balancing multiple considerations. The principle of {principle_1} suggests that {principle_1_implication}, while {principle_2} indicates {principle_2_implication}. Historical precedents in similar cases show that {historical_precedent}. From a consequentialist perspective, we should consider that {consequence_analysis}. Rights-based considerations include {rights_consideration}. A virtue ethics approach would emphasize {virtue_consideration}. The broader societal implications include {societal_implication}.",
    "Analyzing this situation through multiple ethical frameworks: A deontological approach would focus on {deontological_focus}, concluding that {deontological_conclusion}. Utilitarianism would weigh {utilitarian_considerations}, suggesting {utilitarian_conclusion}. Justice considerations highlight {justice_considerations}. Professional ethics in this domain dictate {professional_ethics}. Cultural perspectives may vary, as {cultural_perspective}. Long-term versus short-term impacts create additional complexity because {temporal_complexity}.",
    "This case presents several ethical dimensions worth examining. Regarding consent and autonomy, {consent_analysis}. Privacy considerations include {privacy_analysis}. Fairness and equity issues arise because {fairness_issues}. Transparency requirements would dictate {transparency_requirements}. Accountability mechanisms should include {accountability_mechanisms}. Risk assessment suggests {risk_assessment}. Balancing innovation with caution requires {innovation_balance}.",
]

RECOMMENDATION_TEMPLATES = [
    "Based on this ethical analysis, I recommend {primary_recommendation}. This approach respects {respected_principle} while also acknowledging {acknowledged_concern}. To mitigate potential harms, {mitigation_strategy} should be implemented. Additionally, {secondary_recommendation} would help address remaining concerns. Ongoing {monitoring_approach} will be essential to ensure ethical compliance as the situation evolves.",
    "The most ethically sound course of action would be to {primary_recommendation}. This balances the competing values of {balanced_value_1} and {balanced_value_2}. Key safeguards should include {safeguard_1} and {safeguard_2}. Stakeholder engagement through {engagement_method} will be crucial for maintaining trust. Future evaluations should focus on {evaluation_focus} to ensure continued ethical alignment.",
    "I recommend a multi-faceted approach: First, {recommendation_1} to address immediate concerns. Second, {recommendation_2} as a medium-term solution. Third, develop {recommendation_3} for long-term sustainability. Throughout implementation, prioritize {prioritized_value}. This approach acknowledges trade-offs between {trade_off_values} but optimizes for {optimized_outcome} while minimizing {minimized_harm}.",
    "Given the competing ethical considerations, the most appropriate response is to {primary_recommendation}. This should be accompanied by {accompanying_measure} to ensure {ensured_outcome}. Transparency can be maintained through {transparency_measure}. Affected parties should be {stakeholder_treatment}. Regular {review_process} will help adjust the approach as new information or circumstances emerge.",
]

SYSTEM_TYPES = [
    "an AI-powered recommendation system",
    "a facial recognition platform",
    "an automated decision-making algorithm",
    "a predictive analytics tool",
    "a natural language processing service",
    "a biometric authentication system",
    "an autonomous vehicle navigation system",
    "a behavioral targeting platform",
    "a content moderation algorithm",
    "a data mining infrastructure",
    "an automated surveillance system",
    "a personalized learning algorithm",
    "a sentiment analysis tool",
    "an automated hiring system",
    "a social scoring mechanism",
]

DATA_TYPES = [
    "personal health information",
    "financial transaction history",
    "biometric identifiers",
    "location data",
    "social media activity",
    "behavioral patterns",
    "political opinions",
    "educational records",
    "emotional responses",
    "interpersonal communications",
    "professional qualifications",
    "demographic information",
    "browsing history",
    "genetic information",
    "consumption preferences",
]

PURPOSES = [
    "improve user experience",
    "personalize content delivery",
    "optimize resource allocation",
    "identify potential security threats",
    "streamline decision-making processes",
    "reduce operational costs",
    "increase engagement metrics",
    "predict future behavior",
    "automate compliance verification",
    "enhance public safety",
    "accelerate research outcomes",
    "minimize human bias",
    "maximize conversion rates",
    "improve accessibility",
    "reduce carbon footprint",
]

CONTEXTS = [
    "healthcare settings",
    "public transportation systems",
    "educational institutions",
    "financial services",
    "law enforcement operations",
    "social welfare programs",
    "urban planning initiatives",
    "employment processes",
    "content creation industries",
    "critical infrastructure",
    "disaster response scenarios",
    "retail environments",
    "public spaces",
    "political campaigns",
    "scientific research",
]

CONCERNS = [
    "it may perpetuate existing societal biases",
    "privacy protections may be inadequate",
    "users might not provide meaningful informed consent",
    "the technology could be repurposed for surveillance",
    "it may disproportionately impact vulnerable populations",
    "the decision-making process lacks transparency",
    "there's no clear accountability for harmful outcomes",
    "it could undermine human autonomy",
    "long-term societal impacts haven't been adequately studied",
    "it creates security vulnerabilities that could be exploited",
    "it might amplify misinformation or manipulation",
    "the environmental impact is potentially significant",
    "it could lead to job displacement without transition plans",
    "it may erode important social skills or capacities",
    "it prioritizes efficiency over human wellbeing",
]


class EthicsDataGenerator(SyntheticDataGenerator):
    """Generator for synthetic ethics data."""

    def _load_templates(self) -> Dict[str, Any]:
        """Load ethics templates."""
        templates = {
            "domains": ETHICAL_DOMAINS,
            "principles": ETHICAL_PRINCIPLES,
            "scenarios": SCENARIO_TEMPLATES,
            "analyses": ANALYSIS_TEMPLATES,
            "recommendations": RECOMMENDATION_TEMPLATES,
            "system_types": SYSTEM_TYPES,
            "data_types": DATA_TYPES,
            "purposes": PURPOSES,
            "contexts": CONTEXTS,
            "concerns": CONCERNS,
        }

        # Additional domain-specific templates could be loaded from files
        template_path = self.config.get("template_path")
        if template_path and Path(template_path).exists():
            try:
                with open(template_path, "r", encoding="utf-8") as f:
                    custom_templates = json.load(f)
                    for key, values in custom_templates.items():
                        if key in templates and isinstance(values, list):
                            templates[key].extend(values)
            except Exception as e:
                logger.warning(f"Failed to load custom templates: {e}")

        return templates

    def generate_example(self) -> Dict[str, Any]:
        """Generate a single ethics example."""
        # Select templates
        domain = random.choice(self.templates["domains"])
        scenario_template = random.choice(self.templates["scenarios"])
        analysis_template = random.choice(self.templates["analyses"])
        recommendation_template = random.choice(self.templates["recommendations"])

        # Select random principles (2-4)
        num_principles = random.randint(2, 4)
        principles = random.sample(self.templates["principles"], num_principles)

        # Generate context for the scenario
        system_type = random.choice(self.templates["system_types"])
        data_type = random.choice(self.templates["data_types"])
        purpose = random.choice(self.templates["purposes"])
        context = random.choice(self.templates["contexts"])
        concern = random.choice(self.templates["concerns"])

        # Generate capability and benefits/risks
        capability = self._generate_capability(system_type)
        benefit = self._generate_benefit(capability)
        risk = self._generate_risk(capability)
        criticism = self._generate_criticism(system_type, purpose)
        ethical_question = self._generate_ethical_question(system_type)
        stakeholders = self._generate_stakeholders(context)
        caution = self._generate_caution(system_type, purpose)
        industry = self._generate_industry(capability)
        competing_values = self._generate_competing_values()

        # Fill in scenario template
        scenario_context = {
            "system_type": system_type,
            "data_type": data_type,
            "purpose": purpose,
            "context": context,
            "concern": concern,
            "capability": capability,
            "benefit": benefit,
            "risk": risk,
            "criticism": criticism,
            "ethical_question": ethical_question,
            "stakeholders": stakeholders,
            "caution": caution,
            "industry": industry,
            "competing_values": competing_values,
        }

        scenario = scenario_template.format(**scenario_context)

        # Generate analysis components
        analysis_context = self._generate_analysis_context(
            domain, principles, scenario_context
        )
        analysis = analysis_template.format(**analysis_context)

        # Generate recommendation components
        recommendation_context = self._generate_recommendation_context(analysis_context)
        recommendation = recommendation_template.format(**recommendation_context)

        # Return the structured example
        return {
            "scenario": scenario,
            "ethical_analysis": analysis,
            "recommendation": recommendation,
            "domain": domain,
            "principles": [
                p.split(" - ")[0] for p in principles
            ],  # Just the principle names
            "considerations": self._extract_considerations(analysis),
            "stance": random.choice(["cautious", "balanced", "progressive"]),
            "metadata": {
                "system_type": system_type,
                "context": context,
                "ethical_domain": domain,
                "complexity": random.choice(["low", "medium", "high"]),
            },
        }

    # Helper methods for generating specific content
    def _generate_capability(self, system_type: str) -> str:
        """Generate a capability based on system type."""
        capabilities = {
            "an AI-powered recommendation system": [
                "suggest highly personalized content based on behavioral patterns",
                "predict user preferences with minimal explicit input",
                "adapt recommendations in real-time based on changing behavior",
                "influence user decisions through strategic content presentation",
                "identify vulnerable users for targeted interventions",
            ],
            "a facial recognition platform": [
                "identify individuals in crowded public spaces",
                "track movement patterns across multiple locations",
                "detect emotional states from facial expressions",
                "verify identity without explicit user interaction",
                "categorize individuals based on physical characteristics",
            ],
            "an automated decision-making algorithm": [
                "evaluate complex applications without human review",
                "allocate resources based on predicted outcomes",
                "prioritize cases according to algorithmic criteria",
                "make high-stakes decisions at scale",
                "adjust criteria based on historical outcomes",
            ],
        }

        # Return specific capability if available, otherwise generic
        if system_type in capabilities:
            return random.choice(capabilities[system_type])
        else:
            generic_capabilities = [
                "process large amounts of data to make predictions",
                "automate traditionally human decision processes",
                "identify patterns invisible to human analysts",
                "scale operations beyond human capabilities",
                "integrate multiple data sources for comprehensive analysis",
            ]
            return random.choice(generic_capabilities)

    def _generate_benefit(self, capability: str) -> str:
        """Generate a potential benefit based on capability."""
        benefits = [
            "improve efficiency and reduce costs",
            "enhance accuracy and reliability",
            "provide services to previously underserved populations",
            "reduce human bias in important decisions",
            "accelerate innovation in critical fields",
            "increase safety through constant monitoring",
            "personalize experiences to individual needs",
            "scale solutions to meet growing demand",
            "enable more timely interventions in critical situations",
            "democratize access to specialized expertise",
        ]
        return random.choice(benefits)

    def _generate_risk(self, capability: str) -> str:
        """Generate a potential risk based on capability."""
        risks = [
            "it could be used for unauthorized surveillance",
            "sensitive data might be vulnerable to breaches",
            "algorithmic biases could lead to discriminatory outcomes",
            "it might create a false sense of objectivity",
            "human oversight could be inappropriately reduced",
            "it could amplify existing social inequalities",
            "unintended consequences might emerge at scale",
            "it might be difficult to correct errors once deployed",
            "malicious actors could exploit vulnerabilities",
            "it could erode important social norms or skills",
        ]
        return random.choice(risks)

    def _generate_criticism(self, system_type: str, purpose: str) -> str:
        """Generate criticism of the system and purpose."""
        criticisms = [
            "the system lacks adequate oversight mechanisms",
            "informed consent processes are insufficient",
            "privacy protections don't meet international standards",
            "the technology disproportionately burdens marginalized communities",
            "transparency requirements have been minimized for commercial reasons",
            "the system creates unacceptable power imbalances",
            "long-term societal implications haven't been adequately considered",
            "the technology perpetuates harmful social categorizations",
            "stated benefits are exaggerated while risks are downplayed",
            "alternatives with fewer ethical concerns haven't been properly explored",
        ]
        return random.choice(criticisms)

    def _generate_ethical_question(self, system_type: str) -> str:
        """Generate an ethical question about the system."""
        questions = [
            "considering who controls access to the resulting data",
            "examining who bears the costs versus who receives the benefits",
            "determining appropriate limitations on its use",
            "considering implications for human autonomy and dignity",
            "evaluating its impact on social relationships and institutions",
            "questioning whether adequate safeguards exist",
            "considering how it might shape future technological development",
            "examining how it might alter power dynamics",
            "determining whether it creates unacceptable vulnerabilities",
            "considering how responsibility for outcomes is assigned",
        ]
        return random.choice(questions)

    def _generate_stakeholders(self, context: str) -> str:
        """Generate stakeholders based on context."""
        stakeholders = {
            "healthcare settings": "patients, healthcare providers, and insurers",
            "educational institutions": "students, educators, and parents",
            "financial services": "customers, financial institutions, and regulators",
            "law enforcement operations": "citizens, officers, and legal advocates",
        }

        # Return specific stakeholders if available, otherwise generic
        if context in stakeholders:
            return stakeholders[context]
        else:
            generic_stakeholders = [
                "users, service providers, and regulators",
                "consumers, businesses, and government agencies",
                "citizens, private entities, and public institutions",
                "individuals, communities, and organizational leaders",
                "current users, potential users, and third parties",
            ]
            return random.choice(generic_stakeholders)

    def _generate_caution(self, system_type: str, purpose: str) -> str:
        """Generate a caution about the system and purpose."""
        cautions = [
            "the technology could compromise patient confidentiality in unexpected ways",
            "algorithmic decisions might not account for important contextual factors",
            "the system could create harmful dependencies on proprietary technology",
            "the focus on quantifiable metrics might neglect qualitative human values",
            "there's insufficient evidence for the system's long-term effectiveness",
            "technical limitations could lead to harmful false positives or negatives",
            "the technology might erode important human skills or capacities",
            "it could create unrealistic expectations about technological solutions",
            "vulnerable populations might be inadequately represented in development",
            "implementation might prioritize institutional convenience over user needs",
        ]
        return random.choice(cautions)

    def _generate_industry(self, capability: str) -> str:
        """Generate an industry that might be disrupted."""
        industries = [
            "healthcare diagnostics",
            "financial advisory services",
            "educational assessment",
            "creative content production",
            "transportation and logistics",
            "customer service operations",
            "legal research and documentation",
            "security and surveillance",
            "human resources and recruitment",
            "market research and consumer insights",
        ]
        return random.choice(industries)

    def _generate_competing_values(self) -> str:
        """Generate competing ethical values."""
        value_pairs = [
            "innovation and caution",
            "efficiency and inclusivity",
            "personalization and privacy",
            "automation and human oversight",
            "progress and tradition",
            "individual choice and collective welfare",
            "transparency and intellectual property",
            "convenience and security",
            "access and quality control",
            "standardization and flexibility",
        ]
        return random.choice(value_pairs)

    def _generate_analysis_context(
        self, domain: str, principles: List[str], scenario_context: Dict[str, str]
    ) -> Dict[str, str]:
        """Generate context for ethical analysis."""
        # Split principles into name and description
        principle_names = [p.split(" - ")[0] for p in principles]

        context = {
            # Principles analysis
            "principle_1": principle_names[0],
            "principle_1_reason": self._generate_principle_reason(
                principle_names[0], scenario_context
            ),
            "principle_2": principle_names[1],
            "principle_2_reason": self._generate_principle_reason(
                principle_names[1], scenario_context
            ),
            "principle_1_implication": self._generate_principle_implication(
                principle_names[0]
            ),
            "principle_2_implication": self._generate_principle_implication(
                principle_names[1]
            ),
            # Competing values
            "competing_value_1": random.choice(
                ["innovation", "efficiency", "progress", "accessibility", "convenience"]
            ),
            "competing_value_2": random.choice(
                ["caution", "equity", "privacy", "security", "quality"]
            ),
            "tension_explanation": self._generate_tension_explanation(),
            # Consequences
            "consequence_1": self._generate_consequence(
                scenario_context, positive=True
            ),
            "condition_1": self._generate_condition(positive=True),
            "consequence_2": self._generate_consequence(
                scenario_context, positive=False
            ),
            "condition_2": self._generate_condition(positive=False),
            "consequence_analysis": self._generate_consequence_analysis(),
            # Stakeholders
            "stakeholder_1": self._generate_stakeholder_type(),
            "priority_1": self._generate_priority(),
            "stakeholder_2": self._generate_stakeholder_type(),
            "priority_2": self._generate_priority(),
            # Historical and precedent
            "historical_precedent": self._generate_historical_precedent(),
            # Rights and virtues
            "rights_consideration": self._generate_rights_consideration(),
            "virtue_consideration": self._generate_virtue_consideration(),
            "societal_implication": self._generate_societal_implication(),
            # Ethical frameworks
            "deontological_focus": self._generate_deontological_focus(),
            "deontological_conclusion": self._generate_deontological_conclusion(),
            "utilitarian_considerations": self._generate_utilitarian_considerations(),
            "utilitarian_conclusion": self._generate_utilitarian_conclusion(),
            "justice_considerations": self._generate_justice_considerations(),
            "professional_ethics": self._generate_professional_ethics(),
            "cultural_perspective": self._generate_cultural_perspective(),
            "temporal_complexity": self._generate_temporal_complexity(),
            # Specific ethical dimensions
            "consent_analysis": self._generate_consent_analysis(),
            "privacy_analysis": self._generate_privacy_analysis(),
            "fairness_issues": self._generate_fairness_issues(),
            "transparency_requirements": self._generate_transparency_requirements(),
            "accountability_mechanisms": self._generate_accountability_mechanisms(),
            "risk_assessment": self._generate_risk_assessment(),
            "innovation_balance": self._generate_innovation_balance(),
        }

        return context

    def _generate_principle_reason(
        self, principle: str, scenario_context: Dict[str, str]
    ) -> str:
        """Generate a reason why a principle is relevant."""
        system_type = scenario_context["system_type"]

        reasons = {
            "autonomy": [
                f"the {system_type} could limit individual choices without their awareness",
                f"users might not fully understand how the {system_type} influences their decisions",
                "the technology might create subtle forms of manipulation or coercion",
            ],
            "beneficence": [
                f"the {system_type} must demonstrably improve outcomes for those it affects",
                "any technology should prioritize creating positive impacts for users and society",
                "the claimed benefits need careful evaluation against potential harms",
            ],
            "non-maleficence": [
                "even unintended consequences must be anticipated and mitigated",
                f"the {system_type} could create new vulnerabilities or risks",
                "harm prevention should take precedence over feature development",
            ],
            "justice": [
                f"benefits and burdens of the {system_type} may be unevenly distributed",
                "existing inequalities could be amplified by the technology",
                "fair access to the benefits must be ensured across different groups",
            ],
            "transparency": [
                f"users should understand how the {system_type} works and affects them",
                "the inner workings of the system must not be a 'black box'",
                "people have a right to know how decisions about them are being made",
            ],
            "accountability": [
                "clear responsibility must be established for any harmful outcomes",
                f"someone must be answerable when the {system_type} fails or causes harm",
                "mechanisms for redress need to be accessible to those affected",
            ],
            "privacy": [
                f"the {system_type} collects sensitive information that requires protection",
                "data collection should be minimized to what's necessary",
                "users should maintain control over their personal information",
            ],
            "consent": [
                "meaningful permission requires genuine understanding and choice",
                "users must be able to withdraw their participation without penalty",
                "implied consent is insufficient for this level of intervention",
            ],
        }

        # Return specific reason if available, otherwise generic
        if principle.lower() in reasons:
            return random.choice(reasons[principle.lower()])
        else:
            generic_reasons = [
                f"ethical deployment of {system_type} requires careful consideration of this principle",
                "this fundamental value must be protected despite technological advancement",
                "stakeholders have expressed specific concerns related to this principle",
            ]
            return random.choice(generic_reasons)

    def _generate_principle_implication(self, principle: str) -> str:
        """Generate implications of a principle."""
        implications = {
            "autonomy": [
                "user control should be maximized through opt-in features and clear choices",
                "systems should be designed to enhance rather than replace human judgment",
                "meaningful alternatives must be available without significant penalties",
            ],
            "beneficence": [
                "we should prioritize features that provide demonstrable benefits to users",
                "proactive measures to promote well-being should be incorporated",
                "positive impacts should be measurable and verified independently",
            ],
            "non-maleficence": [
                "rigorous testing for potential harms must precede deployment",
                "ongoing monitoring for unexpected negative effects is essential",
                "safety mechanisms should be redundant and fail-secure",
            ],
            "justice": [
                "access and benefits should be equitably distributed across demographics",
                "additional support may be needed for disadvantaged groups",
                "pricing and availability should not create or reinforce divisions",
            ],
            "transparency": [
                "explanations should be accessible to users with varying technical literacy",
                "documentation should include both technical details and plain language summaries",
                "the limits and confidence levels of the system should be clearly disclosed",
            ],
        }

        # Return specific implication if available, otherwise generic
        if principle.lower() in implications:
            return random.choice(implications[principle.lower()])
        else:
            generic_implications = [
                "we must design systems with this principle as a foundational requirement",
                "technical capabilities should never override this ethical consideration",
                "policies and practices should reflect this value throughout implementation",
            ]
            return random.choice(generic_implications)

    def _generate_tension_explanation(self) -> str:
        """Generate explanation of tension between competing values."""
        explanations = [
            "maximizing one often requires compromising the other in practical implementation",
            "stakeholders prioritize these values differently based on their perspectives",
            "short-term demands often favor one while long-term sustainability requires the other",
            "technical constraints make it difficult to fully satisfy both simultaneously",
            "existing regulatory frameworks tend to emphasize one over the other",
            "market incentives typically reward one more directly than the other",
            "historical precedents have created an imbalance between these values",
            "public discourse often presents these as binary choices rather than complementary goals",
        ]
        return random.choice(explanations)

    def _generate_consequence(
        self, scenario_context: Dict[str, str], positive: bool
    ) -> str:
        """Generate a consequence based on the scenario."""
        if positive:
            consequences = [
                "user outcomes could significantly improve",
                "accessibility would increase for underserved populations",
                "operational efficiency would enable broader service delivery",
                "costs would decrease while maintaining quality",
                "innovation in related fields would accelerate",
                "human error would be reduced in critical processes",
                "timely interventions would prevent negative outcomes",
                "resource allocation would become more equitable",
            ]
        else:
            consequences = [
                "some users might experience new forms of exclusion",
                "privacy erosion could occur incrementally and irreversibly",
                "dependency on proprietary systems might limit future choices",
                "important human skills could atrophy from disuse",
                "accountability might become diffused and ineffective",
                "unexpected failure modes could emerge at scale",
                "societal norms might shift in potentially harmful ways",
                "power imbalances could be exacerbated between groups",
            ]
        return random.choice(consequences)

    def _generate_condition(self, positive: bool) -> str:
        """Generate a condition for consequences."""
        if positive:
            conditions = [
                "proper safeguards are implemented from the beginning",
                "diverse perspectives are included throughout development",
                "transparent operations are maintained consistently",
                "regular independent audits verify compliance",
                "user feedback mechanisms are robust and responsive",
                "adaptive governance evolves with the technology",
                "benefits are explicitly shared across stakeholder groups",
                "continuous education keeps users informed and empowered",
            ]
        else:
            conditions = [
                "commercial pressures override ethical considerations",
                "deployment occurs without adequate testing",
                "regulatory oversight fails to keep pace with innovation",
                "user understanding lags behind implementation",
                "technical complexity obscures important trade-offs",
                "powerful interests dominate decision-making processes",
                "short-term metrics drive optimization at the expense of long-term values",
                "security vulnerabilities remain unaddressed",
            ]
        return random.choice(conditions)

    def _generate_stakeholder_type(self) -> str:
        """Generate a stakeholder type."""
        stakeholders = [
            "direct users",
            "service providers",
            "regulatory bodies",
            "vulnerable populations",
            "industry competitors",
            "civil society organizations",
            "technical developers",
            "academic researchers",
            "future generations",
            "institutional purchasers",
        ]
        return random.choice(stakeholders)

    def _generate_priority(self) -> str:
        """Generate a stakeholder priority."""
        priorities = [
            "maximum functionality and convenience",
            "data security and privacy protections",
            "cost efficiency and scalability",
            "accessibility and inclusivity",
            "reliability and consistency",
            "innovation and competitive advantage",
            "compliance and risk mitigation",
            "user control and customization",
            "simplicity and ease of understanding",
            "integration with existing systems",
        ]
        return random.choice(priorities)

    def _generate_consequence_analysis(self) -> str:
        """Generate analysis of consequences."""
        analyses = [
            "immediate benefits must be weighed against potential long-term harms",
            "both intended and unintended consequences require thorough examination",
            "the distribution of benefits and harms across different groups is asymmetric",
            "second-order effects may be more significant than primary outcomes",
            "probabilistic harms must be taken seriously even if uncertain",
            "comparative analysis with alternatives shows important trade-offs",
            "systemic impacts may differ significantly from individual-level effects",
            "threshold effects could create tipping points with cascading consequences",
        ]
        return random.choice(analyses)

    def _generate_historical_precedent(self) -> str:
        """Generate historical precedent."""
        precedents = [
            "early adoption without adequate safeguards has repeatedly led to harmful outcomes",
            "similar technologies have evolved to include stronger protections over time",
            "initial concerns often materialize in unexpected ways during scaling",
            "retroactive regulation has proven difficult once systems are widely deployed",
            "stakeholder inclusion has consistently improved outcomes in similar cases",
            "transparency requirements have increased following documented abuses",
            "ethical frameworks have matured through iterative real-world applications",
            "public trust has proven difficult to rebuild once compromised",
        ]
        return random.choice(precedents)

    def _generate_rights_consideration(self) -> str:
        """Generate rights-based considerations."""
        considerations = [
            "the right to privacy requires meaningful control over personal information",
            "informational self-determination is fundamental to human dignity",
            "equal treatment before automated systems is an emerging right",
            "the right to explanation is increasingly recognized in algorithmic contexts",
            "freedom from manipulation requires protection from subtle influences",
            "cognitive liberty includes freedom from excessive technological nudging",
            "meaningful human review should be available for significant decisions",
            "rights to access and rectification are essential for data subjects",
        ]
        return random.choice(considerations)

    def _generate_virtue_consideration(self) -> str:
        """Generate virtue ethics considerations."""
        considerations = [
            "technologies should be designed to encourage human flourishing",
            "systems should promote rather than undermine ethical character development",
            "virtues like honesty and fairness should be embedded in system design",
            "responsible innovation requires practical wisdom and moderation",
            "compassion should guide decisions about vulnerable users",
            "courage is needed to prioritize ethics over expediency",
            "intellectual humility recognizes the limits of algorithmic solutions",
            "prudence is essential when deploying technologies with uncertain impacts",
        ]
        return random.choice(considerations)

    def _generate_societal_implication(self) -> str:
        """Generate societal implications."""
        implications = [
            "social cohesion could be affected as technology mediates more interactions",
            "civic discourse might be transformed in both positive and negative ways",
            "power dynamics between institutions and individuals may shift significantly",
            "collective decision-making processes could be enhanced or undermined",
            "social norms regarding privacy and disclosure may evolve rapidly",
            "intergenerational equity requires considering future impacts",
            "cultural diversity in ethical standards must be respected",
            "democratic oversight of technological development may face new challenges",
        ]
        return random.choice(implications)

    def _generate_deontological_focus(self) -> str:
        """Generate deontological focus."""
        focuses = [
            "whether the technology respects the inherent dignity of all persons",
            "if users are treated as ends in themselves rather than merely as means",
            "whether actions would be acceptable if universally applied",
            "the intentions behind the system's design and deployment",
            "whether the technology honors fundamental duties to users",
            "if rights are being respected regardless of consequences",
            "whether all stakeholders are treated with equal moral consideration",
            "if the design process respects the moral autonomy of users",
        ]
        return random.choice(focuses)

    def _generate_deontological_conclusion(self) -> str:
        """Generate deontological conclusion."""
        conclusions = [
            "the current approach requires modification to fully respect human dignity",
            "certain elements violate the categorical imperative and must be reconsidered",
            "the design treats some users merely as means rather than as ends",
            "fundamental duties to users are being upheld in principle but not in practice",
            "rights-based considerations suggest significant changes are needed",
            "the approach is permissible if informed consent is genuinely secured",
            "intentions appear sound but implementation fails to honor core duties",
            "moral consistency would require extending similar protections to all affected parties",
        ]
        return random.choice(conclusions)

    def _generate_utilitarian_considerations(self) -> str:
        """Generate utilitarian considerations."""
        considerations = [
            "the aggregate benefits and harms across all affected parties",
            "whether alternative approaches might produce greater net welfare",
            "how to quantify intangible impacts like privacy or autonomy",
            "the distribution of utility across different stakeholder groups",
            "long-term versus short-term utility calculations",
            "the reliability of predictions about future consequences",
            "preference satisfaction versus objective welfare measures",
            "rule-utilitarian versus act-utilitarian perspectives",
        ]
        return random.choice(considerations)

    def _generate_utilitarian_conclusion(self) -> str:
        """Generate utilitarian conclusion."""
        conclusions = [
            "the likely benefits appear to outweigh potential harms if safeguards are implemented",
            "alternative approaches could produce greater overall utility with less risk",
            "a more targeted implementation would optimize the benefit-to-harm ratio",
            "the uncertainty of long-term impacts suggests a more cautious approach",
            "a phased rollout would allow for utility assessment before full deployment",
            "potential harms to vulnerable minorities outweigh aggregate benefits",
            "the utility calculation changes significantly when considering second-order effects",
            "maximizing long-term utility requires stronger oversight mechanisms",
        ]
        return random.choice(conclusions)

    def _generate_justice_considerations(self) -> str:
        """Generate justice considerations."""
        considerations = [
            "disparate impacts across demographic groups require mitigation",
            "access barriers could create new forms of inequality",
            "procedural justice demands transparent decision criteria",
            "distribution of benefits should prioritize the least advantaged",
            "historical injustices might be perpetuated or amplified",
            "fairness requires similar treatment in similar circumstances",
            "capabilities and opportunities may be affected asymmetrically",
            "intergenerational justice considerations for long-lived systems",
        ]
        return random.choice(considerations)

    def _generate_professional_ethics(self) -> str:
        """Generate professional ethics considerations."""
        considerations = [
            "practitioners must prioritize public welfare above other interests",
            "professional codes of conduct require transparency about limitations",
            "conflicts of interest must be disclosed and managed appropriately",
            "the duty of care extends to foreseeable impacts of technical work",
            "professional standards require ongoing competence as technology evolves",
            "collaboration across disciplines is needed for ethical assessment",
            "whistleblower protections should be available for ethical concerns",
            "professional integrity requires refusing work that violates ethical principles",
        ]
        return random.choice(considerations)

    def _generate_cultural_perspective(self) -> str:
        """Generate cultural perspective considerations."""
        considerations = [
            "privacy expectations vary significantly across cultural contexts",
            "concepts of fairness and justice have cultural dimensions",
            "some communities may value collective benefits differently than individual rights",
            "technological solutionism itself reflects particular cultural assumptions",
            "diverse cultural perspectives should inform ethical frameworks",
            "global deployment requires cultural sensitivity in implementation",
            "different historical experiences shape risk perception across cultures",
            "cultural values influence acceptable trade-offs and priorities",
        ]
        return random.choice(considerations)

    def _generate_temporal_complexity(self) -> str:
        """Generate temporal complexity considerations."""
        considerations = [
            "short-term efficiency gains may come at the cost of long-term resilience",
            "path dependencies created today will shape options for future generations",
            "adaptive capacity must be preserved for responding to emerging issues",
            "technological lock-in can limit future ethical choices",
            "values and norms evolve while deployed systems may remain static",
            "reversibility becomes increasingly difficult as adoption spreads",
            "learning curves for new technologies create temporary vulnerabilities",
            "long-term maintenance of ethical standards requires ongoing vigilance",
        ]
        return random.choice(considerations)

    def _generate_consent_analysis(self) -> str:
        """Generate consent analysis."""
        analyses = [
            "truly informed consent requires genuine understanding of complex systems",
            "default opt-in approaches often fail to secure meaningful consent",
            "power imbalances can render formal consent procedures inadequate",
            "consent should be dynamic and revocable as circumstances change",
            "alternatives must be available without punitive consequences",
            "consent interfaces often prioritize convenience over comprehension",
            "special considerations apply for vulnerable or dependent users",
            "presumed consent is inappropriate for novel applications with uncertain risks",
        ]
        return random.choice(analyses)

    def _generate_privacy_analysis(self) -> str:
        """Generate privacy analysis."""
        analyses = [
            "data minimization should be a foundational design principle",
            "purpose limitation prevents function creep and unexpected uses",
            "privacy by design requires proactive rather than reactive measures",
            "differential privacy techniques could provide mathematical guarantees",
            "data retention policies should align with necessity rather than utility",
            "re-identification risks increase as data sets are combined",
            "privacy impact assessments should precede new data uses",
            "contextual integrity considers appropriate information flows",
        ]
        return random.choice(analyses)

    def _generate_fairness_issues(self) -> str:
        """Generate fairness issues."""
        issues = [
            "historical data often contains embedded biases that models reproduce",
            "different fairness metrics may be mutually incompatible",
            "seemingly neutral criteria can create disparate impacts",
            "underrepresented groups often face higher error rates",
            "feedback loops can amplify initial inequalities over time",
            "proxy variables may reinstate bias even when protected attributes are excluded",
            "fairness requires ongoing monitoring rather than one-time certification",
            "different stakeholders may have legitimate but conflicting fairness definitions",
        ]
        return random.choice(issues)

    def _generate_transparency_requirements(self) -> str:
        """Generate transparency requirements."""
        requirements = [
            "explanations should be accessible to users with varying technical literacy",
            "decision criteria must be documentable and justifiable",
            "both technical mechanisms and governance processes require transparency",
            "meaningful transparency includes understanding system limitations",
            "audit trails should track key decisions and modifications",
            "transparency may need to be tailored differently for various stakeholders",
            "trade secrets should not prevent appropriate oversight",
            "algorithmic impact assessments should be publicly available",
        ]
        return random.choice(requirements)

    def _generate_accountability_mechanisms(self) -> str:
        """Generate accountability mechanisms."""
        mechanisms = [
            "clear lines of responsibility for outcomes regardless of complexity",
            "accessible processes for contesting decisions and seeking redress",
            "regular independent audits of performance and impacts",
            "penalties proportionate to potential harms for non-compliance",
            "whistleblower protections for reporting ethical concerns",
            "ongoing monitoring with stakeholder involvement",
            "documentation requirements that enable external review",
            "grievance mechanisms that include support for affected parties",
        ]
        return random.choice(mechanisms)

    def _generate_risk_assessment(self) -> str:
        """Generate risk assessment."""
        assessments = [
            "potential harms should be evaluated systematically before deployment",
            "low-probability but high-impact risks warrant serious consideration",
            "risk distribution across different populations requires explicit analysis",
            "compounding risks from system interactions may be overlooked",
            "unknown risks require adaptive governance and ongoing vigilance",
            "reversibility and containment options limit potential damage",
            "risk thresholds should be determined through inclusive deliberation",
            "precautionary principles apply when risks are uncertain but potentially severe",
        ]
        return random.choice(assessments)

    def _generate_innovation_balance(self) -> str:
        """Generate innovation balance."""
        balances = [
            "ethical guardrails should channel rather than prevent innovation",
            "staged deployment can balance progress with caution",
            "innovation sandboxes allow testing under controlled conditions",
            "principles-based approaches provide flexibility with accountability",
            "participatory design incorporates diverse perspectives from the outset",
            "value-sensitive design embeds ethical considerations in development",
            "anticipatory governance prepares for emerging challenges",
            "responsible innovation frameworks align technical and social progress",
        ]
        return random.choice(balances)

    def _generate_recommendation_context(
        self, analysis_context: Dict[str, str]
    ) -> Dict[str, str]:
        """Generate context for recommendation."""

        # Primary recommendations based on analysis
        primary_recommendations = [
            "implement the system with enhanced transparency measures and opt-in consent",
            "proceed with a limited pilot program with robust monitoring mechanisms",
            "redesign key components to address identified ethical concerns",
            "establish an independent oversight committee with diverse representation",
            "develop clear usage guidelines with explicit ethical boundaries",
            "adopt a phased implementation approach with checkpoints for review",
            "incorporate additional safeguards for vulnerable populations",
            "create a comprehensive data governance framework before proceeding",
        ]

        # Mitigation strategies
        mitigation_strategies = [
            "regular algorithmic audits by independent third parties",
            "ongoing monitoring with clear thresholds for intervention",
            "robust anonymization techniques for all personal data",
            "user-friendly controls for privacy preferences",
            "accessible explanations of system operation and limitations",
            "formal impact assessments before major updates",
            "channels for stakeholder feedback and reported concerns",
            "sunset provisions requiring periodic reauthorization",
        ]

        # Secondary recommendations
        secondary_recommendations = [
            "develop educational resources to promote informed user decisions",
            "establish an ethics advisory board with rotating membership",
            "create a transparent incident response protocol",
            "implement differential access levels based on necessity",
            "require regular public reporting on system performance and impacts",
            "develop industry standards for similar technologies",
            "establish compensation mechanisms for demonstrated harms",
            "invest in research addressing identified ethical challenges",
        ]

        # Generate the recommendation context
        context = {
            "primary_recommendation": random.choice(primary_recommendations),
            "respected_principle": random.choice(
                ["autonomy", "beneficence", "justice", "transparency", "privacy"]
            ),
            "acknowledged_concern": random.choice(
                [
                    "potential biases",
                    "privacy risks",
                    "accessibility barriers",
                    "security vulnerabilities",
                    "oversight limitations",
                ]
            ),
            "mitigation_strategy": random.choice(mitigation_strategies),
            "secondary_recommendation": random.choice(secondary_recommendations),
            "monitoring_approach": random.choice(
                [
                    "impact assessment",
                    "stakeholder feedback",
                    "outcome metrics",
                    "independent auditing",
                    "automated monitoring",
                ]
            ),
            # For the second template
            "balanced_value_1": analysis_context["competing_value_1"],
            "balanced_value_2": analysis_context["competing_value_2"],
            "safeguard_1": random.choice(
                [
                    "data minimization protocols",
                    "explicit user consent mechanisms",
                    "algorithmic fairness checks",
                    "human oversight for critical decisions",
                    "robust security measures",
                ]
            ),
            "safeguard_2": random.choice(
                [
                    "regular third-party audits",
                    "transparent documentation",
                    "accessible appeals process",
                    "ongoing stakeholder consultation",
                    "sunset provisions",
                ]
            ),
            "engagement_method": random.choice(
                [
                    "public consultations",
                    "representative advisory panels",
                    "user feedback mechanisms",
                    "community review boards",
                    "multi-stakeholder governance",
                ]
            ),
            "evaluation_focus": random.choice(
                [
                    "impact on vulnerable groups",
                    "unintended consequences",
                    "efficacy of safeguards",
                    "changing risk landscape",
                    "evolving social norms",
                ]
            ),
            # For the third template
            "recommendation_1": random.choice(
                [
                    "implement enhanced transparency measures",
                    "strengthen consent procedures",
                    "establish clear boundaries for use",
                    "create oversight mechanisms",
                    "develop explicit ethical guidelines",
                ]
            ),
            "recommendation_2": random.choice(
                [
                    "regular independent audits",
                    "ongoing stakeholder engagement",
                    "robust monitoring protocols",
                    "expanded user controls",
                    "comprehensive documentation",
                ]
            ),
            "recommendation_3": random.choice(
                [
                    "industry-wide ethical standards",
                    "policy frameworks for governance",
                    "research programs on ethical dimensions",
                    "educational initiatives for users",
                    "collaborative oversight mechanisms",
                ]
            ),
            "prioritized_value": random.choice(
                [
                    "human dignity",
                    "informed autonomy",
                    "equitable access",
                    "harm prevention",
                    "accountability",
                ]
            ),
            "trade_off_values": random.choice(
                [
                    "innovation and caution",
                    "efficiency and inclusivity",
                    "personalization and privacy",
                    "automation and oversight",
                    "scale and sensitivity",
                ]
            ),
            "optimized_outcome": random.choice(
                [
                    "long-term trust",
                    "sustainable innovation",
                    "equitable benefits",
                    "resilient systems",
                    "ongoing improvement",
                ]
            ),
            "minimized_harm": random.choice(
                [
                    "exclusion of vulnerable groups",
                    "privacy violations",
                    "erosion of autonomy",
                    "unfair treatment",
                    "unaccountable outcomes",
                ]
            ),
            # For the fourth template
            "accompanying_measure": random.choice(
                [
                    "robust oversight mechanisms",
                    "comprehensive documentation",
                    "ongoing impact assessment",
                    "accessible control options",
                    "proactive risk mitigation",
                ]
            ),
            "ensured_outcome": random.choice(
                [
                    "equitable access",
                    "meaningful consent",
                    "appropriate use",
                    "accountability for outcomes",
                    "ongoing improvement",
                ]
            ),
            "transparency_measure": random.choice(
                [
                    "public documentation",
                    "algorithmic explainability",
                    "regular disclosure reports",
                    "accessible descriptions of processes",
                    "notification of significant changes",
                ]
            ),
            "stakeholder_treatment": random.choice(
                [
                    "actively consulted throughout implementation",
                    "provided with meaningful opt-out options",
                    "given accessible channels for feedback",
                    "included in oversight processes",
                    "informed of their rights and options",
                ]
            ),
            "review_process": random.choice(
                [
                    "independent audits",
                    "stakeholder consultations",
                    "impact assessments",
                    "performance evaluations",
                    "ethical compliance reviews",
                ]
            ),
        }

        return context

    def _extract_considerations(self, analysis: str) -> List[str]:
        """Extract key considerations from the analysis."""
        # This is a simplified version - in a real implementation,
        # this could use NLP techniques to extract actual considerations
        considerations = [
            "Balancing innovation with ethical safeguards",
            "Ensuring meaningful informed consent",
            "Protecting privacy and data security",
            "Preventing algorithmic bias and discrimination",
            "Maintaining appropriate human oversight",
            "Establishing clear lines of accountability",
            "Providing transparency in operation and decisions",
            "Considering impacts on vulnerable populations",
        ]

        # Randomly select 3-5 considerations
        return random.sample(considerations, random.randint(3, 5))


# Register the generator
SyntheticDataGeneratorRegistry.register("ethics", EthicsDataGenerator)