code_generator.py

import re
from typing import Dict, Any, List
from clemscript_templates import ClemScriptTemplates

class CodeGenerator:
    """Générateur de code ClemScript basé sur l'analyse des prompts"""
    
    def __init__(self):
        self.templates = ClemScriptTemplates()
    
    def generate_code(self, analysis: Dict[str, Any], original_prompt: str) -> str:
        """Génère le code ClemScript basé sur l'analyse intelligente du prompt"""
        concepts = analysis.get('concepts', [])
        values = analysis.get('values', {})
        confidence_scores = analysis.get('confidence_scores', {})
        context = analysis.get('context', {})
        intent = analysis.get('intent', 'général')
        
        if not concepts:
            return self._generate_fallback_code(original_prompt)
        
        # Génération contextuelle intelligente
        generated_parts = []
        
        # Prioriser les concepts par score de confiance
        sorted_concepts = sorted(concepts, key=lambda x: confidence_scores.get(x, 0), reverse=True)
        
        for concept in sorted_concepts:
            # Utiliser la méthode existante pour l'instant
            code_part = self._generate_concept_code(concept, values, original_prompt)
            if code_part:
                generated_parts.append(code_part)
        
        # Combiner toutes les parties générées avec améliorations
        if generated_parts:
            # Ajouter des commentaires si le contexte le justifie
            if context.get('complexity') == 'complexe':
                final_code = f"# Code généré pour: {original_prompt}\n\n" + '\n\n'.join(generated_parts)
            else:
                final_code = '\n\n'.join(generated_parts)
            return final_code
        else:
            return self._generate_fallback_code(original_prompt)
    
    def _generate_concept_code(self, concept: str, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour un concept spécifique avec intelligence avancée"""
        
        if concept == 'variable':
            return self._generate_variable_code(values)
        elif concept == 'console':
            return self._generate_console_code(values, prompt)
        elif concept == 'condition':
            return self._generate_condition_code(values, prompt)
        elif concept == 'boucle':
            return self._generate_boucle_code(values)
        elif concept == 'input':
            return self._generate_input_code(values, prompt)
        elif concept == 'math':
            return self._generate_math_code(values)
        elif concept == 'color':
            return self._generate_color_code(values, prompt)
        elif concept == 'quiz':
            return self._generate_quiz_code(values, prompt)
        elif concept == 'interaction':
            return self._generate_smart_interaction_code(values, prompt)
        elif concept == 'random':
            return self._generate_random_code(values)
        elif concept == 'comment':
            return self._generate_comment_code(values, prompt)
        elif concept == 'function':
            return self._generate_function_code(values, prompt)
        elif concept == 'animation':
            return self._generate_animation_code(values, prompt)
        elif concept == 'audio':
            return self._generate_audio_code(values, prompt)
        elif concept == 'data':
            return self._generate_data_code(values, prompt)
        elif concept == 'ai':
            return self._generate_ai_code(values, prompt)
        elif concept == 'network':
            return self._generate_network_code(values, prompt)
        elif concept == 'game':
            return self._generate_game_code(values, prompt)
        
        return ""
    
    def _generate_variable_code(self, values: Dict[str, Any]) -> str:
        """Génère le code pour une déclaration de variable"""
        var_name = values.get('variable_name', 'x')
        var_value = values.get('variable_value')
        
        if not var_value and 'numbers' in values:
            var_value = values['numbers'][0]
        elif not var_value and 'strings' in values:
            var_value = f'"{values["strings"][0]}"'
        elif not var_value:
            var_value = '10'
        
        # Détecter si c'est une chaîne ou un nombre
        if isinstance(var_value, str) and not var_value.isdigit() and not var_value.startswith('"'):
            template = self.templates.get_template('variable', 'string')
            return template.format(name=var_name, value=var_value)
        else:
            template = self.templates.get_template('variable', 'number')
            return template.format(name=var_name, value=var_value)
    
    def _generate_console_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour l'affichage console"""
        if 'strings' in values:
            message = values['strings'][0]
            template = self.templates.get_template('console', 'simple')
            return template.format(message=message)
        elif 'variable_name' in values:
            var_name = values['variable_name']
            template = self.templates.get_template('console', 'variable')
            return template.format(variable=var_name)
        else:
            # Extraire le message du prompt
            message_patterns = [
                r'affiche\s+(?:le\s+message\s+)?["\']?([^"\']+)["\']?',
                r'(?:message|texte)\s+["\']?([^"\']+)["\']?',
                r'["\']([^"\']+)["\']'
            ]
            
            for pattern in message_patterns:
                match = re.search(pattern, prompt.lower())
                if match:
                    message = match.group(1).strip()
                    template = self.templates.get_template('console', 'simple')
                    return template.format(message=message)
            
            # Fallback
            template = self.templates.get_template('console', 'simple')
            return template.format(message="Bonjour le monde")
    
    def _generate_condition_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour une condition"""
        var_name = values.get('variable_name', 'x')
        comparison = values.get('comparison', '>')
        
        # Chercher la valeur de comparaison
        comp_value = '10'
        if 'numbers' in values and len(values['numbers']) > 0:
            comp_value = values['numbers'][0]
        
        condition = f"{var_name} {comparison} {comp_value}"
        
        # Générer le corps de la condition
        if 'strings' in values:
            body = f'Clem console Script -> "{values["strings"][0]}";'
        else:
            # Extraire l'action du prompt
            action_match = re.search(r'(?:alors|then)\s+(.+?)(?:$|\.|;)', prompt.lower())
            if action_match:
                action = action_match.group(1).strip()
                if 'affiche' in action:
                    msg_match = re.search(r'affiche\s+(.+)', action)
                    if msg_match:
                        message = msg_match.group(1).strip()
                        body = f'Clem console Script -> "{message}";'
                    else:
                        body = f'Clem console Script -> "Condition vraie";'
                else:
                    body = f'Clem console Script -> "Condition vraie";'
            else:
                body = f'Clem console Script -> "Condition vraie";'
        
        template = self.templates.get_template('condition', 'simple')
        return template.format(condition=condition, body='    ' + body)
    
    def _generate_boucle_code(self, values: Dict[str, Any]) -> str:
        """Génère le code pour une boucle"""
        start = '1'
        end = '5'
        
        # Utiliser les valeurs extraites spécifiquement pour les boucles
        if 'loop_start' in values and 'loop_end' in values:
            start = values['loop_start']
            end = values['loop_end']
        elif 'numbers' in values and len(values['numbers']) >= 2:
            start = values['numbers'][0]
            end = values['numbers'][1]
        elif 'numbers' in values and len(values['numbers']) == 1:
            end = values['numbers'][0]
        
        template = self.templates.get_template('boucle', 'for_simple')
        return template.format(start=start, end=end)
    
    def _generate_input_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour la saisie utilisateur"""
        var_name = values.get('variable_name', 'reponse')
        
        # Extraire le message de prompt
        prompt_message = "Entrez votre réponse: "
        if 'strings' in values:
            prompt_message = values['strings'][0]
        else:
            # Chercher dans le prompt original
            input_match = re.search(r'(?:demande|saisie|input).+?["\']([^"\']+)["\']', prompt.lower())
            if input_match:
                prompt_message = input_match.group(1)
        
        template = self.templates.get_template('input', 'with_response')
        return template.format(variable=var_name, prompt=prompt_message)
    
    def _generate_math_code(self, values: Dict[str, Any]) -> str:
        """Génère le code pour les opérations mathématiques"""
        if 'numbers' in values:
            value = values['numbers'][0]
        else:
            value = '5'
        
        # Utiliser l'opération spécifique détectée
        if 'math_operation' in values:
            operation = values['math_operation']
            # Mapper les opérations françaises vers les fonctions ClemScript
            operation_map = {
                'carré': 'square',
                'racine': 'sqrt', 
                'valeur absolue': 'abs',
                'square': 'square',
                'sqrt': 'sqrt',
                'abs': 'abs'
            }
            clemscript_op = operation_map.get(operation, 'square')
            template = self.templates.get_template('math', clemscript_op)
            return template.format(result='resultat', value=value)
        else:
            # Par défaut, utiliser square
            template = self.templates.get_template('math', 'square')
            return template.format(result='resultat', value=value)
    
    def _generate_color_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour l'affichage coloré"""
        color = 'green'
        if 'colors' in values:
            color = values['colors'][0]
        
        message = "Message coloré"
        if 'strings' in values:
            message = values['strings'][0]
        
        template = self.templates.get_template('color', 'simple')
        return template.format(color=color, message=message)
    
    def _generate_quiz_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour un quiz"""
        # Utiliser le template simple par défaut
        return self.templates.get_template('quiz', 'simple')
    
    def _generate_interaction_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour une interaction"""
        keywords = values.get('keywords', ['forêt', 'montagne'])
        
        # Formater les mots-clés (prendre jusqu'à 3 mots-clés)
        keywords_str = '"' + '", "'.join(keywords[:3]) + '"'
        
        # Générer les réponses plus intelligemment
        responses = []
        if 'responses' in values:
            for response, keyword in values['responses']:
                responses.append(f'    Clem console Script -> "{response.strip()}";')
        else:
            # Générer des réponses basées sur les mots-clés
            if 'forêt' in keywords:
                responses.append('    Clem console Script -> "Vous explorez la mystérieuse forêt!";')
            elif 'montagne' in keywords:
                responses.append('    Clem console Script -> "Vous escaladez la haute montagne!";')
            elif 'océan' in keywords or 'mer' in keywords:
                responses.append('    Clem console Script -> "Vous naviguez sur l\'océan bleu!";')
            else:
                responses.append('    Clem console Script -> "Vous avez fait un choix valide!";')
        
        template = self.templates.get_template('interaction', 'basic')
        return template.format(
            prompt="Choisissez votre destination: ",
            keywords=keywords_str,
            responses='\n'.join(responses)
        )
    
    def _generate_random_code(self, values: Dict[str, Any]) -> str:
        """Génère le code pour la génération aléatoire"""
        if 'numbers' in values and len(values['numbers']) >= 2:
            min_val = values['numbers'][0]
            max_val = values['numbers'][1]
            template = self.templates.get_template('random', 'number')
            return template.format(min=min_val, max=max_val)
        else:
            # Génération de texte aléatoire par défaut
            texts = '"Bonjour", "Salut", "Coucou"'
            if 'strings' in values:
                texts = '"' + '", "'.join(values['strings']) + '"'
            template = self.templates.get_template('random', 'text')
            return template.format(texts=texts)
    
    def _generate_comment_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour un commentaire"""
        if 'strings' in values:
            comment = values['strings'][0]
        else:
            # Extraire le commentaire du prompt
            comment_match = re.search(r'(?:commentaire|note|explication)\s+["\']?([^"\']+)["\']?', prompt.lower())
            if comment_match:
                comment = comment_match.group(1)
            else:
                comment = "Commentaire automatique"
        
        template = self.templates.get_template('comment', 'basic')
        return template.format(comment=comment)
    
    def _generate_function_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère le code pour une fonction"""
        func_name = values.get('variable_name', 'ma_fonction')
        
        # Générer le corps de la fonction
        body = '    Clem console Script -> "Fonction exécutée";'
        if 'strings' in values:
            body = f'    Clem console Script -> "{values["strings"][0]}";'
        
        template = self.templates.get_template('function', 'basic')
        return template.format(name=func_name, body=body)
    
    def _generate_fallback_code(self, prompt: str) -> str:
        """Génère un code de fallback quand aucun concept n'est détecté"""
        # Essayer de détecter une intention basique
        if any(word in prompt.lower() for word in ['bonjour', 'salut', 'hello']):
            return 'Clem console Script -> "Bonjour le monde!";'
        elif any(word in prompt.lower() for word in ['variable', 'var']):
            return 'Clem var Script x = 10;'
        elif any(word in prompt.lower() for word in ['affiche', 'montre', 'print']):
            return 'Clem console Script -> "Message par défaut";'
        else:
            return '''# Code ClemScript généré
Clem console Script -> "Bienvenue dans ClemScript!";
Clem var Script exemple = 42;
Clem console Script -> "Valeur: " + exemple;'''
    
    def _generate_smart_interaction_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère des interactions intelligentes basées sur l'analyse avancée"""
        
        # Utiliser les choix détectés automatiquement
        if 'detected_choices' in values:
            choices = values['detected_choices']
            
            # Générer le code d'interaction avec les choix détectés
            interaction_code = f'Clem var Script choix;\\nClem input Script choix "Choisissez parmi: {", ".join(choices)}";\\n\\n'
            
            # Ajouter les réponses mappées si disponibles
            if 'response_mappings' in values:
                for mapping in values['response_mappings']:
                    condition = mapping['condition']
                    response = mapping['response']
                    interaction_code += f'Clem if Script (choix == "{condition}") Clem then Script {{\\n    Clem console Script -> "{response}";\\n}}\\n'
            else:
                # Générer des réponses par défaut pour chaque choix
                for choice in choices:
                    interaction_code += f'Clem if Script (choix == "{choice}") Clem then Script {{\\n    Clem console Script -> "Vous avez choisi: {choice}";\\n}}\\n'
            
            return interaction_code
        
        # Mode aventure détecté
        elif values.get('adventure_mode'):
            locations = values.get('adventure_locations', ['forêt', 'montagne', 'océan'])
            
            adventure_code = f'Clem var Script destination;\\nClem input Script destination "Où voulez-vous aller? ({", ".join(locations)})";\\n\\n'
            
            for location in locations:
                adventure_code += f'Clem if Script (destination == "{location}") Clem then Script {{\\n    Clem console Script -> "Vous explorez la {location}. Que voulez-vous faire?";\\n}}\\n'
            
            return adventure_code
        
        # Utiliser la méthode d'interaction classique comme fallback
        return self._generate_interaction_code(values, prompt)
    
    # Nouvelles méthodes pour les concepts avancés
    def _generate_animation_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère du code pour les animations"""
        element = values.get('variable_name', 'objet')
        return f'Clem animation Script {element} "transition" 2000;\\nClem console Script -> "{element} animé avec succès!";'
    
    def _generate_audio_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère du code pour l'audio"""
        sound_name = values.get('variable_name', 'son')
        return f'Clem audio Script play "{sound_name}.wav";\\nClem console Script -> "Son {sound_name} joué!";'
    
    def _generate_data_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère du code pour la gestion des données"""
        data_name = values.get('variable_name', 'donnees')
        return f'Clem data Script load "{data_name}.json";\\nClem console Script -> "Données {data_name} chargées!";'
    
    def _generate_ai_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère du code pour l'IA"""
        model_name = values.get('variable_name', 'modele')
        return f'Clem ai Script predict {model_name} input;\\nClem console Script -> "Prédiction IA effectuée!";'
    
    def _generate_network_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère du code pour le réseau"""
        url = values.get('strings', ['api.exemple.com'])[0] if 'strings' in values else 'api.exemple.com'
        return f'Clem network Script get "{url}";\\nClem console Script -> "Requête réseau envoyée!";'
    
    def _generate_game_code(self, values: Dict[str, Any], prompt: str) -> str:
        """Génère du code pour les jeux"""
        game_name = values.get('variable_name', 'jeu')
        score = values.get('numbers', ['0'])[0] if 'numbers' in values else '0'
        return f'Clem game Script init "{game_name}";\\nClem var Script score = {score};\\nClem console Script -> "Jeu {game_name} initialisé! Score: " + score;'