from smolagents.tools import Tool
import string
import pronouncing
import json

class ParodyWordSuggestionTool(Tool):
    name = "parody_word_suggester"
    description = """Suggests phonetically similar funny words using CMU dictionary pronunciations.
    Returns similar words from a curated list of funny words, along with their similarity scores."""
    inputs = {'target': {'type': 'string', 'description': 'The word you want to find funny alternatives for'}, 'word_list': {'type': 'string', 'description': 'JSON string of words list, e.g. \'["word1", "word2"]\''}, 'min_similarity': {'type': 'string', 'description': 'Minimum similarity threshold (0.0-1.0)', 'nullable': True}}
    output_type = "string"

    def forward(self, target: str, word_list: str, min_similarity: str = "0.7") -> str:
        """Get phonetically similar funny word suggestions."""
        import pronouncing
        import string
        import json
    
        target = target.lower().strip(string.punctuation)
        min_similarity = float(min_similarity)
        suggestions = []
    
        # Parse word list from JSON string
        try:
            words = json.loads(word_list)
            if not isinstance(words, list):
                return json.dumps({
                    "error": "word_list must be a JSON string representing a list of words",
                    "suggestions": []
                }, indent=2)
        except json.JSONDecodeError:
            return json.dumps({
                "error": "Invalid JSON string for word_list",
                "suggestions": []
            }, indent=2)
        
        # Get target pronunciation
        target_phones = pronouncing.phones_for_word(target)
        if not target_phones:
            return json.dumps({
                "error": f"'{target}' not found in CMU dictionary",
                "suggestions": []
            }, indent=2)
        
        target_phones = target_phones[0].split()
    
        # Check each word
        for word in words:
            phones = pronouncing.phones_for_word(word)
            if phones:  # Only process if word is in dictionary
                phones = phones[0].split()
            
                # Calculate similarity using overlap
                overlap = len(set(phones) & set(target_phones))
                total = min(len(phones), len(target_phones))
                similarity = overlap / total if total > 0 else 0.0
            
                if similarity >= min_similarity:
                    suggestions.append({
                        "word": word,
                        "similarity": round(similarity, 3),
                        "syllables": pronouncing.syllable_count(phones)
                    })
    
        # Sort by similarity score descending
        suggestions.sort(key=lambda x: x["similarity"], reverse=True)
    
        result = {
            "target": target,
            "target_syllables": pronouncing.syllable_count(target_phones),
            "suggestions": suggestions
        }
    
        return json.dumps(result, indent=2)


    def __init__(self, *args, **kwargs):
        self.is_initialized = False