src/enhancements/technical/debugging.py

"""
Debugging Assistant Module

Provides debugging assistance and error analysis.
"""

from typing import Dict, List, Optional, Any, Tuple
import re


class DebuggingAssistant:
    """Helps debug code and analyze errors."""

    # Common error patterns and their explanations
    ERROR_PATTERNS = {
        "python": {
            "SyntaxError": {
                "description": "Python syntax is invalid",
                "common_causes": [
                    "Missing colon after if/for/while/function definitions",
                    "Mismatched parentheses or brackets",
                    "Incorrect indentation",
                    "Using Python 2 syntax in Python 3",
                ],
            },
            "NameError": {
                "description": "A variable or function name is not defined",
                "common_causes": [
                    "Typo in variable name",
                    "Variable used before assignment",
                    "Import statement missing",
                    "Scope issue - variable not accessible",
                ],
            },
            "TypeError": {
                "description": "Operation applied to wrong type",
                "common_causes": [
                    "Trying to concatenate incompatible types",
                    "Calling a non-callable as a function",
                    "Passing wrong number of arguments",
                    "Operation not supported for type",
                ],
            },
            "IndexError": {
                "description": "List index out of range",
                "common_causes": [
                    "Accessing index that doesn't exist",
                    "Empty list access",
                    "Off-by-one error",
                ],
            },
            "KeyError": {
                "description": "Dictionary key not found",
                "common_causes": [
                    "Accessing non-existent key",
                    "Typo in key name",
                    "Case sensitivity issue",
                ],
            },
            "AttributeError": {
                "description": "Object has no attribute",
                "common_causes": [
                    "Typo in attribute name",
                    "Object is None when trying to access attribute",
                    "Wrong type for this operation",
                ],
            },
            "ImportError": {
                "description": "Cannot import module",
                "common_causes": [
                    "Module not installed",
                    "Circular import",
                    "Module name typo",
                    "Missing __init__.py in package",
                ],
            },
            "ZeroDivisionError": {
                "description": "Division by zero",
                "common_causes": [
                    "Dividing by variable that could be zero",
                    "Modulo by zero",
                ],
            },
            "ValueError": {
                "description": "Value is inappropriate",
                "common_causes": [
                    "Invalid argument to function",
                    "Conversion failed (e.g., int('abc'))",
                    "Empty sequence in function expecting content",
                ],
            },
            "IndentationError": {
                "description": "Incorrect indentation",
                "common_causes": [
                    "Mixing tabs and spaces",
                    "Inconsistent indentation levels",
                    "Code not aligned properly",
                ],
            },
        },
        "javascript": {
            "ReferenceError": {
                "description": "Variable not defined",
                "common_causes": [
                    "Typo in variable name",
                    "Using let/const before declaration",
                ],
            },
            "TypeError": {
                "description": "Type operation failed",
                "common_causes": [
                    "Calling non-function",
                    "Cannot read property of undefined/null",
                ],
            },
            "SyntaxError": {
                "description": "Invalid syntax",
                "common_causes": [
                    "Missing closing bracket/parenthesis",
                    "Invalid string quotes",
                ],
            },
        },
    }

    def __init__(self):
        """Initialize debugging assistant."""
        pass

    def analyze_error(
        self,
        error_message: str,
        language: str = "python",
    ) -> Dict[str, Any]:
        """
        Analyze an error message and provide debugging help.

        Args:
            error_message: The error message
            language: Programming language

        Returns:
            Dictionary with error analysis and suggestions
        """
        # Extract error type
        error_type = self._extract_error_type(error_message, language)

        # Get error info
        error_info = self.ERROR_PATTERNS.get(language, {}).get(error_type, {
            "description": "Unknown error",
            "common_causes": ["Check the error message for clues"],
        })

        # Generate debugging steps
        steps = self._generate_debug_steps(error_type, error_message, language)

        # Suggest fixes
        fixes = self._suggest_fixes(error_type, error_message, language)

        return {
            "error_type": error_type,
            "description": error_info["description"],
            "common_causes": error_info["common_causes"],
            "debug_steps": steps,
            "suggested_fixes": fixes,
        }

    def _extract_error_type(self, error_message: str, language: str) -> str:
        """Extract error type from error message."""
        # Look for common error patterns
        patterns = {
            "python": [
                (r"(\w+Error):", 1),
                (r"(\w+Exception):", 1),
            ],
            "javascript": [
                (r"(\w+Error):", 1),
                (r"(\w+TypeError):", 1),
            ],
        }

        for pattern, group in patterns.get(language, []):
            match = re.search(pattern, error_message)
            if match:
                return match.group(group)

        return "UnknownError"

    def _generate_debug_steps(
        self,
        error_type: str,
        error_message: str,
        language: str,
    ) -> List[str]:
        """Generate debugging steps for the error."""
        steps = [
            "1. Read the error message carefully - it tells you what went wrong",
            "2. Check the line number in the traceback",
            "3. Look at the context around that line",
        ]

        if error_type == "NameError":
            steps.extend([
                "4. Check if the variable is spelled correctly",
                "5. Verify the variable is defined before use",
                "6. Check if you need to import the module",
            ])
        elif error_type == "TypeError":
            steps.extend([
                "4. Check the types of variables involved",
                "5. Use print() or logging to debug values",
                "6. Use type() to check variable types",
            ])
        elif error_type == "IndexError":
            steps.extend([
                "4. Check the list length before accessing",
                "5. Consider using try/except for bounds",
                "6. Check if the list is empty",
            ])
        elif error_type == "ImportError":
            steps.extend([
                "4. Verify the package is installed (pip list / npm list)",
                "5. Check the package name is correct",
                "6. Try reinstalling the package",
            ])

        return steps

    def _suggest_fixes(
        self,
        error_type: str,
        error_message: str,
        language: str,
    ) -> List[str]:
        """Suggest fixes for the error."""
        fixes = []

        if error_type == "NameError":
            fixes.append("Check spelling of all variable/function names")
            fixes.append("Ensure variable is defined before use")
            fixes.append("Add necessary import statements")
        elif error_type == "TypeError":
            fixes.append("Convert types explicitly if needed")
            fixes.append("Check you're using the right operators")
            fixes.append("Verify function accepts the arguments given")
        elif error_type == "IndexError":
            fixes.append("Add bounds checking before access")
            fixes.append("Use .get() for dictionaries")
            fixes.append("Check if list is empty first")
        elif error_type == "SyntaxError":
            fixes.append("Check for missing colons, brackets, quotes")
            fixes.append("Verify indentation is consistent")
            fixes.append("Run a linter to find issues")

        return fixes

    def analyze_traceback(self, traceback: str) -> Dict[str, Any]:
        """
        Analyze a full traceback.

        Args:
            traceback: The full error traceback

        Returns:
            Dictionary with traceback analysis
        """
        lines = traceback.split('\n')

        # Extract file and line numbers
        file_lines = []
        for line in lines:
            if 'File "' in line or 'line ' in line:
                file_lines.append(line.strip())

        # Get the main error
        error_line = ""
        for line in lines:
            if 'Error:' in line or 'Exception:' in line:
                error_line = line.strip()
                break

        return {
            "files_involved": file_lines,
            "main_error": error_line,
            "frames": len([l for l in lines if 'File "' in l]),
        }

    def generate_debug_code(
        self,
        error_type: str,
        code_snippet: str,
    ) -> str:
        """Generate debugging code for the error."""
        debug_templates = {
            "NameError": f"""# Debug NameError
# Add debugging print statements
print(f"Variable value: {{variable_name}}")

# Check if defined
try:
    result = {code_snippet}
except NameError as e:
    print(f"NameError: {{e}}")""",

            "TypeError": f"""# Debug TypeError
# Add type checking
print(f"Type of variable: {{type(variable_name)}}")

# Add type hints for clarity
def debug_function(variable_name):
    print(f"Value: {{variable_name}}, Type: {{type(variable_name)}}")
    return variable_name""",

            "IndexError": f"""# Debug IndexError
# Add bounds checking
my_list = []

if len(my_list) > 0:
    print(f"List has {{len(my_list)}} items")
    # Access with safety
    result = my_list[0] if my_list else None""",

            "default": """# General debug approach
import traceback

try:
    # Your code here
    pass
except Exception as e:
    print(f"Error: {{e}}")
    traceback.print_exc()
    # Add your debugging here"""
        }

        return debug_templates.get(error_type, debug_templates["default"])

    def suggest_logging(self, code: str) -> str:
        """Suggest where to add logging statements."""
        suggestions = []

        # Suggest logging for function calls
        functions = re.findall(r'def\s+(\w+)\s*\(', code)
        for func in functions[:3]:  # Limit to 3
            suggestions.append(f"Add logging at start/end of function '{func}()'")

        # Suggest logging for error handling
        if "except" in code:
            suggestions.append("Add logging in exception handlers")

        # Suggest logging for loops
        if "for " in code:
            suggestions.append("Add logging in loops to track iterations")

        return suggestions if suggestions else ["Code looks simple, minimal logging needed"]

    def __repr__(self) -> str:
        return "DebuggingAssistant()"