benchmark/parameter_generator.py

"""
Parameter Generator - Generate random values for question parameters

This module provides functionality to generate random values for different
parameter types within reasonable and realistic ranges.
"""

import random
from typing import Dict, Any, List
from decimal import Decimal
from eth_account import Account


class ParameterGenerator:
    """Generate random parameter values based on configuration"""
    
    def __init__(self, seed: int = None, environment=None):
        """
        Initialize parameter generator
        
        Args:
            seed: Random seed for reproducibility (optional)
            environment: QuestEnvironment instance for accessing deployed contracts
        """
        if seed is not None:
            random.seed(seed)
        self.environment = environment
    
    def generate_parameters(self, param_config: Dict[str, Any]) -> Dict[str, Any]:
        """
        Generate random values for all parameters based on configuration
        
        Args:
            param_config: Parameter configuration dictionary
            
        Returns:
            Dictionary of parameter names to generated values
        """
        result = {}
        
        for param_name, config in param_config.items():
            param_type = config.get('type')
            generation_config = config.get('generation', {})
            
            if param_type == 'address':
                result[param_name] = self._generate_address(generation_config)
            elif param_type == 'number':
                result[param_name] = self._generate_number(generation_config)
            elif param_type == 'string':
                result[param_name] = self._generate_string(generation_config)
            elif param_type == 'integer':
                result[param_name] = self._generate_integer(generation_config)
            elif param_type == 'boolean':
                result[param_name] = self._generate_boolean(generation_config)
            else:
                raise ValueError(f"Unsupported parameter type: {param_type}")
        
        return result
    
    def _generate_address(self, config: Dict[str, Any]) -> str:
        """
        Generate a random Ethereum address
        
        Args:
            config: Generation configuration
                - method: 'random', 'fixed', 'from_list', or 'from_env'
                - value: Fixed address value (if method is 'fixed')
                - addresses: List of addresses (if method is 'from_list')
                - env_key: Key to lookup in environment (if method is 'from_env')
                
        Returns:
            Ethereum address (checksummed)
        """
        method = config.get('method', 'random')
        
        if method == 'fixed':
            # Return fixed address value
            return config.get('value', '')
        elif method == 'random':
            # Generate a new random account
            account = Account.create()
            return account.address
        elif method == 'from_list':
            # Choose from predefined list
            addresses = config.get('addresses', [])
            if not addresses:
                raise ValueError("No addresses provided in configuration")
            return random.choice(addresses)
        elif method == 'from_env':
            # Get from environment (e.g., deployed contract address)
            env_key = config.get('env_key')
            if not env_key:
                raise ValueError("env_key not provided for from_env method")
            
            # If environment not available yet, return a placeholder
            # This will be replaced later when environment is ready
            if not self.environment:
                # Generate a placeholder address
                placeholder = Account.create()
                return placeholder.address
            
            # Get the address from environment
            address = getattr(self.environment, env_key, None)
            if not address:
                raise ValueError(f"Address not found in environment: {env_key}")
            return address
        elif method == 'agent_address':
            # Return the test account address (agent's own address)
            if self.environment and hasattr(self.environment, 'test_address'):
                return self.environment.test_address
            else:
                # Generate a placeholder if environment not available
                placeholder = Account.create()
                return placeholder.address
        else:
            raise ValueError(f"Unsupported address generation method: {method}")
    
    def _generate_number(self, config: Dict[str, Any]) -> float:
        """
        Generate a number (float or int)
        
        Args:
            config: Generation configuration
                - method: 'fixed' or 'random' (default: 'random')
                - value: Fixed value if method is 'fixed'
                - min: Minimum value (default: 0.001)
                - max: Maximum value (default: 1.0)
                - decimals: Number of decimal places (default: 3)
                - unit: Unit of measurement (e.g., 'BNB', 'ETH')
                
        Returns:
            Number value (float or int)
        """
        from decimal import Decimal, ROUND_HALF_UP
        
        method = config.get('method', 'random')
        
        if method == 'fixed':
            return config.get('value', 0)
        
        # Random generation
        min_val = config.get('min', 0.001)
        max_val = config.get('max', 1.0)
        decimals = config.get('decimals', 3)
        
        # Generate random value using Decimal for precision
        # This avoids floating point precision issues when converting to wei
        min_decimal = Decimal(str(min_val))
        max_decimal = Decimal(str(max_val))
        
        # Generate random decimal
        random_decimal = min_decimal + (max_decimal - min_decimal) * Decimal(str(random.random()))
        
        # Round to specified decimals
        quantize_value = Decimal(10) ** -decimals
        rounded = random_decimal.quantize(quantize_value, rounding=ROUND_HALF_UP)
        
        # Convert back to float
        return float(rounded)
    
    def _generate_integer(self, config: Dict[str, Any]) -> int:
        """
        Generate a random integer
        
        Args:
            config: Generation configuration
                - method: 'random', 'fixed', or 'from_list'
                - value: Fixed value (if method is 'fixed')
                - values: List of values to choose from (if method is 'from_list')
                - min: Minimum value (default: 1)
                - max: Maximum value (default: 100)
                
        Returns:
            Random integer value, fixed value, or value from list
        """
        method = config.get('method', 'random')
        
        if method == 'fixed':
            return config.get('value', 0)
        
        if method == 'from_list':
            values = config.get('values', [])
            if not values:
                raise ValueError("from_list method requires 'values' list")
            return random.choice(values)
        
        # Random method
        min_val = config.get('min', 1)
        max_val = config.get('max', 100)
        
        return random.randint(min_val, max_val)
    
    def _generate_string(self, config: Dict[str, Any]) -> str:
        """
        Generate a random string
        
        Args:
            config: Generation configuration
                - method: 'from_list' or 'random'
                - values: List of possible values (if method is 'from_list')
                - length: String length (if method is 'random')
                - charset: Character set (if method is 'random')
                
        Returns:
            Random string value
        """
        method = config.get('method', 'from_list')
        
        if method == 'fixed':
            # Return fixed string value
            return config.get('value', '')
        elif method == 'from_list':
            values = config.get('values', [])
            if not values:
                raise ValueError("No values provided in configuration")
            return random.choice(values)
        elif method == 'random':
            length = config.get('length', 10)
            charset = config.get('charset', 'alphanumeric')
            
            if charset == 'alphanumeric':
                import string
                chars = string.ascii_letters + string.digits
            elif charset == 'alphanumeric_space':
                import string
                chars = string.ascii_letters + string.digits + ' '
            elif charset == 'alpha':
                import string
                chars = string.ascii_letters
            elif charset == 'numeric':
                import string
                chars = string.digits
            else:
                chars = charset
            
            return ''.join(random.choice(chars) for _ in range(length))
        else:
            raise ValueError(f"Unsupported string generation method: {method}")
    
    def _generate_boolean(self, config: Dict[str, Any]) -> bool:
        """
        Generate a boolean value
        
        Args:
            config: Generation configuration
                - method: 'fixed' or 'random' (default: 'random')
                - value: Fixed value if method is 'fixed'
                - probability: Probability of True (default: 0.5) if method is 'random'
                
        Returns:
            Boolean value
        """
        method = config.get('method', 'random')
        
        if method == 'fixed':
            return config.get('value', False)
        else:
            # Random generation
            probability = config.get('probability', 0.5)
            return random.random() < probability


def format_parameter_value(value: Any, param_config: Dict[str, Any]) -> str:
    """
    Format a parameter value for TypeScript code injection
    
    IMPORTANT: This function formats values for direct injection into TypeScript code.
    For numeric values that will be passed to ethers.parseEther() or ethers.parseUnits(),
    we must return ONLY the numeric string WITHOUT units (e.g., "0.024", not "0.024 BNB").
    
    Args:
        value: The parameter value
        param_config: Parameter configuration
        
    Returns:
        Formatted string representation (pure value, no units for numbers)
    """
    param_type = param_config.get('type')
    
    if param_type == 'number':
        # Return pure numeric string WITHOUT units
        # Units are for documentation only, not for code injection
        # Example: "0.024" (not "0.024 BNB") so ethers.parseEther('0.024') works
        return str(value)
    elif param_type == 'address':
        # Address as-is
        return str(value)
    elif param_type == 'integer':
        # Return pure integer string WITHOUT units
        # Example: "18" (not "18 decimals")
        return str(value)
    elif param_type == 'boolean':
        # Convert Python True/False to JavaScript true/false (lowercase)
        return 'true' if value else 'false'
    else:
        return str(value)