from typing import Dict, List, Optional
import random

class CodeGenerator:
    """A class to generate function code in multiple programming languages."""
    
    # Supported languages and their templates with proper indentation
    TEMPLATES: Dict[str, str] = {
        "python": "def {func_name}({params}):\n    {body}",
        "javascript": "function {func_name}({params}) {{\n    {body}\n}}",
        "cpp": "{ret_type} {func_name}({params}) {{\n    {body}\n}}",
        "java": "public class Main {{\n    public static {ret_type} {func_name}({params}) {{\n        {body}\n    }}\n}}",
        "csharp": "public class Program {{\n    public static {ret_type} {func_name}({params}) {{\n        {body}\n    }}\n}}"
    }

    # Configuration data
    FUNCTION_NAMES: List[str] = ["calculate", "processData", "computeValue", "generateOutput"]
    DEFAULT_PARAMS: Dict[str, str] = {
        "python": "x: int, y: int",
        "javascript": "x, y",
        "cpp": "int x, int y",
        "java": "int x, int y",
        "csharp": "int x, int y"
    }
    RETURN_TYPES: Dict[str, str] = {
        "cpp": "int",
        "java": "int",
        "csharp": "int",
        "python": " -> int",  # Type hint for Python
        "javascript": ""      # No explicit return type
    }
    DEFAULT_BODY: str = "return x + y;"
    
    def __init__(self, seed: Optional[int] = None):
        """Initialize generator with optional random seed."""
        if seed is not None:
            random.seed(seed)

    def get_supported_languages(self) -> List[str]:
        """Return list of supported languages."""
        return list(self.TEMPLATES.keys())

    def generate_code(
        self,
        language: str,
        func_name: Optional[str] = None,
        params: Optional[str] = None,
        body: Optional[str] = None,
        ret_type: Optional[str] = None
    ) -> Optional[str]:
        """
        Generate code for the specified language with customizable components.
        
        Args:
            language: Target programming language
            func_name: Optional custom function name
            params: Optional custom parameters
            body: Optional custom function body
            ret_type: Optional custom return type
            
        Returns:
            Generated code string or None if language is unsupported
        """
        if language not in self.TEMPLATES:
            return None

        # Use provided values or defaults
        selected_func_name = func_name or random.choice(self.FUNCTION_NAMES)
        selected_params = params or self.DEFAULT_PARAMS.get(language, "")
        selected_body = self._normalize_body(body or self.DEFAULT_BODY, language)
        selected_ret_type = ret_type or self.RETURN_TYPES.get(language, "")

        try:
            return self.TEMPLATES[language].format(
                func_name=selected_func_name,
                params=selected_params,
                body=selected_body,
                ret_type=selected_ret_type
            )
        except KeyError as e:
            raise ValueError(f"Missing template component: {str(e)}")
        except Exception as e:
            raise RuntimeError(f"Code generation failed: {str(e)}")

    def _normalize_body(self, body: str, language: str) -> str:
        """Normalize function body based on language requirements."""
        body = body.strip()
        if language in {"cpp", "java", "csharp"} and not body.endswith(";"):
            return body + ";"
        if language == "python":
            return body.replace(";", "")  # Python doesn't use semicolons
        return body

def main():
    """Demonstrate code generation for all supported languages."""
    generator = CodeGenerator(seed=42)  # Fixed seed for reproducibility
    
    print("Supported languages:", generator.get_supported_languages())
    print("\nGenerated code examples:")
    
    for lang in generator.get_supported_languages():
        code = generator.generate_code(lang)
        print(f"\n{lang.upper()}:\n{code}")

if __name__ == "__main__":
    main()