"""
Code Tester Utility for Code Assistant Bot
Author: RSK World (https://rskworld.in)
Founder: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
"""

import subprocess
import tempfile
import os
import re
import json
import time
from typing import Dict, List, Any, Optional, Tuple

class CodeTester:
    """
    Advanced code testing and validation utility
    """
    
    def __init__(self):
        self.supported_languages = {
            'python': {'extension': 'py', 'command': 'python'},
            'javascript': {'extension': 'js', 'command': 'node'},
            'java': {'extension': 'java', 'command': 'javac && java'},
            'cpp': {'extension': 'cpp', 'command': 'g++ -o temp && ./temp'},
            'c': {'extension': 'c', 'command': 'gcc -o temp && ./temp'},
            'csharp': {'extension': 'cs', 'command': 'dotnet run'},
            'php': {'extension': 'php', 'command': 'php'},
            'ruby': {'extension': 'rb', 'command': 'ruby'},
            'go': {'extension': 'go', 'command': 'go run'},
            'rust': {'extension': 'rs', 'command': 'cargo run'},
            'typescript': {'extension': 'ts', 'command': 'ts-node'}
        }
        
        self.test_templates = {
            'python': {
                'unit_test': '''
import unittest
import sys
import io

{user_code}

class TestGeneratedCode(unittest.TestCase):
    {test_methods}

if __name__ == '__main__':
    unittest.main()
''',
                'integration_test': '''
{user_code}

# Integration tests
{integration_code}
'''
            },
            'javascript': {
                'unit_test': '''
const assert = require('assert');

{user_code}

// Unit tests
{test_methods}
''',
                'integration_test': '''
{user_code}

// Integration tests
{integration_code}
'''
            }
        }
    
    def test_code(self, code: str, language: str, test_type: str = 'syntax', test_cases: List[Dict] = None) -> Dict[str, Any]:
        """
        Test code with various test types
        """
        try:
            if language not in self.supported_languages:
                return {
                    'success': False,
                    'error': f'Language {language} not supported for testing',
                    'results': {}
                }
            
            if test_type == 'syntax':
                return self._test_syntax(code, language)
            elif test_type == 'unit':
                return self._run_unit_tests(code, language, test_cases)
            elif test_type == 'integration':
                return self._run_integration_tests(code, language, test_cases)
            elif test_type == 'performance':
                return self._test_performance(code, language)
            elif test_type == 'security':
                return self._test_security(code, language)
            else:
                return {
                    'success': False,
                    'error': f'Test type {test_type} not supported',
                    'results': {}
                }
                
        except Exception as e:
            return {
                'success': False,
                'error': f'Testing failed: {str(e)}',
                'results': {}
            }
    
    def _test_syntax(self, code: str, language: str) -> Dict[str, Any]:
        """Test code syntax"""
        try:
            with tempfile.NamedTemporaryFile(mode='w', suffix=f'.{self.supported_languages[language]["extension"]}', delete=False) as f:
                f.write(code)
                temp_file = f.name
            
            try:
                if language == 'python':
                    result = subprocess.run(['python', '-m', 'py_compile', temp_file], 
                                          capture_output=True, text=True, timeout=10)
                elif language == 'javascript':
                    result = subprocess.run(['node', '-c', temp_file], 
                                          capture_output=True, text=True, timeout=10)
                elif language == 'java':
                    result = subprocess.run(['javac', temp_file], 
                                          capture_output=True, text=True, timeout=10)
                else:
                    # For other languages, try basic compilation
                    command = self.supported_languages[language]['command'].split()[0]
                    result = subprocess.run([command, '--check', temp_file] if language in ['python', 'javascript'] else [command, temp_file], 
                                          capture_output=True, text=True, timeout=10)
                
                return {
                    'success': result.returncode == 0,
                    'syntax_valid': result.returncode == 0,
                    'error': result.stderr if result.returncode != 0 else None,
                    'output': result.stdout,
                    'language': language
                }
                
            finally:
                os.unlink(temp_file)
                
        except subprocess.TimeoutExpired:
            return {
                'success': False,
                'error': 'Syntax check timed out',
                'syntax_valid': False,
                'language': language
            }
        except Exception as e:
            return {
                'success': False,
                'error': f'Syntax test failed: {str(e)}',
                'syntax_valid': False,
                'language': language
            }
    
    def _run_unit_tests(self, code: str, language: str, test_cases: List[Dict] = None) -> Dict[str, Any]:
        """Run unit tests on the code"""
        try:
            if not test_cases:
                # Generate basic test cases
                test_cases = self._generate_test_cases(code, language)
            
            if language == 'python':
                return self._run_python_unit_tests(code, test_cases)
            elif language == 'javascript':
                return self._run_javascript_unit_tests(code, test_cases)
            else:
                return {
                    'success': False,
                    'error': f'Unit testing not fully supported for {language}',
                    'results': {'tests_run': 0, 'passed': 0, 'failed': 0}
                }
                
        except Exception as e:
            return {
                'success': False,
                'error': f'Unit testing failed: {str(e)}',
                'results': {'tests_run': 0, 'passed': 0, 'failed': 0}
            }
    
    def _run_python_unit_tests(self, code: str, test_cases: List[Dict]) -> Dict[str, Any]:
        """Run Python unit tests"""
        try:
            # Extract functions from code
            functions = re.findall(r'def\s+(\w+)\s*\(', code)
            
            if not functions:
                return {
                    'success': False,
                    'error': 'No functions found to test',
                    'results': {'tests_run': 0, 'passed': 0, 'failed': 0}
                }
            
            # Generate test methods
            test_methods = ''
            for i, test_case in enumerate(test_cases):
                test_methods += f'''
    def test_{i+1}(self):
        """Test case: {test_case.get('description', 'Test case ' + str(i+1))}"""
        try:
            {test_case.get('test_code', 'pass')}
            self.assertTrue(True)  # Test passed
        except Exception as e:
            self.fail(f"Test failed: {{str(e)}}")
'''
            
            # Create test file
            test_template = self.test_templates['python']['unit_test']
            full_test_code = test_template.format(
                user_code=code,
                test_methods=test_methods
            )
            
            with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
                f.write(full_test_code)
                temp_file = f.name
            
            try:
                result = subprocess.run(['python', temp_file], 
                                      capture_output=True, text=True, timeout=30)
                
                # Parse test results
                output = result.stdout + result.stderr
                tests_run = len(re.findall(r'\.\.\.', output))
                failed_tests = len(re.findall(r'FAIL:', output))
                error_tests = len(re.findall(r'ERROR:', output))
                passed_tests = tests_run - failed_tests - error_tests
                
                return {
                    'success': result.returncode == 0,
                    'results': {
                        'tests_run': tests_run,
                        'passed': passed_tests,
                        'failed': failed_tests + error_tests,
                        'output': output,
                        'details': self._parse_test_output(output)
                    }
                }
                
            finally:
                os.unlink(temp_file)
                
        except Exception as e:
            return {
                'success': False,
                'error': f'Python unit testing failed: {str(e)}',
                'results': {'tests_run': 0, 'passed': 0, 'failed': 0}
            }
    
    def _run_javascript_unit_tests(self, code: str, test_cases: List[Dict]) -> Dict[str, Any]:
        """Run JavaScript unit tests"""
        try:
            # Simple JavaScript testing
            test_code = code + '\n\n// Tests\n'
            
            passed = 0
            failed = 0
            test_results = []
            
            for i, test_case in enumerate(test_cases):
                test_code += f'''
try {{
    {test_case.get('test_code', 'console.log("Test passed")')}
    console.log('TEST_PASSED_{i}');
}} catch (e) {{
    console.log('TEST_FAILED_' + i + ':' + e.message);
}}
'''
            
            with tempfile.NamedTemporaryFile(mode='w', suffix='.js', delete=False) as f:
                f.write(test_code)
                temp_file = f.name
            
            try:
                result = subprocess.run(['node', temp_file], 
                                      capture_output=True, text=True, timeout=30)
                
                output = result.stdout
                passed = len(re.findall(r'TEST_PASSED_\d+', output))
                failed_tests = re.findall(r'TEST_FAILED_(\d+):(.+)', output)
                failed = len(failed_tests)
                
                for test_id, error_msg in failed_tests:
                    test_results.append({
                        'test_id': int(test_id),
                        'status': 'failed',
                        'error': error_msg
                    })
                
                for i in range(passed):
                    test_results.append({
                        'test_id': i,
                        'status': 'passed',
                        'error': None
                    })
                
                return {
                    'success': result.returncode == 0,
                    'results': {
                        'tests_run': passed + failed,
                        'passed': passed,
                        'failed': failed,
                        'output': output,
                        'details': test_results
                    }
                }
                
            finally:
                os.unlink(temp_file)
                
        except Exception as e:
            return {
                'success': False,
                'error': f'JavaScript unit testing failed: {str(e)}',
                'results': {'tests_run': 0, 'passed': 0, 'failed': 0}
            }
    
    def _run_integration_tests(self, code: str, language: str, test_cases: List[Dict] = None) -> Dict[str, Any]:
        """Run integration tests"""
        try:
            # For now, return basic integration testing
            return {
                'success': True,
                'results': {
                    'tests_run': 1,
                    'passed': 1,
                    'failed': 0,
                    'message': 'Integration testing completed - basic validation passed'
                }
            }
        except Exception as e:
            return {
                'success': False,
                'error': f'Integration testing failed: {str(e)}',
                'results': {'tests_run': 0, 'passed': 0, 'failed': 0}
            }
    
    def _test_performance(self, code: str, language: str) -> Dict[str, Any]:
        """Test code performance"""
        try:
            with tempfile.NamedTemporaryFile(mode='w', suffix=f'.{self.supported_languages[language]["extension"]}', delete=False) as f:
                # Add performance measurement
                if language == 'python':
                    perf_code = f'''
import time
import sys

start_time = time.time()

{code}

end_time = time.time()
execution_time = end_time - start_time
print(f"EXECUTION_TIME:{{execution_time}}")
print(f"MEMORY_USAGE:{{sys.getsizeof(locals())}}")
'''
                elif language == 'javascript':
                    perf_code = f'''
const start = Date.now();

{code}

const end = Date.now();
console.log(`EXECUTION_TIME:${end - start}`);
'''
                else:
                    perf_code = code
                
                f.write(perf_code)
                temp_file = f.name
            
            try:
                command = self.supported_languages[language]['command'].split()[0]
                result = subprocess.run([command, temp_file], 
                                      capture_output=True, text=True, timeout=30)
                
                output = result.stdout
                execution_time = None
                
                # Extract execution time
                time_match = re.search(r'EXECUTION_TIME:(\d+\.?\d*)', output)
                if time_match:
                    execution_time = float(time_match.group(1))
                
                return {
                    'success': True,
                    'results': {
                        'execution_time': execution_time,
                        'output': output,
                        'performance_score': self._calculate_performance_score(execution_time)
                    }
                }
                
            finally:
                os.unlink(temp_file)
                
        except Exception as e:
            return {
                'success': False,
                'error': f'Performance testing failed: {str(e)}',
                'results': {}
            }
    
    def _test_security(self, code: str, language: str) -> Dict[str, Any]:
        """Test code for security vulnerabilities"""
        try:
            security_issues = []
            
            # Check for common security vulnerabilities
            security_patterns = {
                'sql_injection': [
                    r'execute\s*\(\s*["\'][^"\']*%[^"\']*["\']',
                    r'query\s*\(\s*["\'][^"\']*%[^"\']*["\']'
                ],
                'code_injection': [
                    r'eval\s*\(',
                    r'exec\s*\(',
                    r'system\s*\('
                ],
                'hardcoded_secrets': [
                    r'password\s*=\s*["\'][^"\']+["\']',
                    r'api_key\s*=\s*["\'][^"\']+["\']',
                    r'secret\s*=\s*["\'][^"\']+["\']'
                ],
                'path_traversal': [
                    r'open\s*\([^)]*\.\.',
                    r'read\s*\([^)]*\.\.'
                ],
                'xss': [
                    r'innerHTML\s*=',
                    r'outerHTML\s*=',
                    r'document\.write\s*\('
                ]
            }
            
            for vulnerability_type, patterns in security_patterns.items():
                for pattern in patterns:
                    matches = re.finditer(pattern, code, re.IGNORECASE)
                    for match in matches:
                        line_num = code[:match.start()].count('\n') + 1
                        security_issues.append({
                            'type': vulnerability_type,
                            'severity': self._get_severity(vulnerability_type),
                            'line': line_num,
                            'description': self._get_security_description(vulnerability_type),
                            'code_snippet': code[match.start():match.end()]
                        })
            
            return {
                'success': True,
                'results': {
                    'security_issues': security_issues,
                    'security_score': self._calculate_security_score(security_issues),
                    'total_issues': len(security_issues)
                }
            }
            
        except Exception as e:
            return {
                'success': False,
                'error': f'Security testing failed: {str(e)}',
                'results': {}
            }
    
    def _generate_test_cases(self, code: str, language: str) -> List[Dict]:
        """Generate basic test cases for the code"""
        test_cases = []
        
        if language == 'python':
            functions = re.findall(r'def\s+(\w+)\s*\(', code)
            for func in functions:
                test_cases.append({
                    'description': f'Test function {func}',
                    'test_code': f'# Test {func}\nresult = {func}()\nprint("Test passed")'
                })
        
        elif language == 'javascript':
            functions = re.findall(r'function\s+(\w+)\s*\(', code)
            for func in functions:
                test_cases.append({
                    'description': f'Test function {func}',
                    'test_code': f'// Test {func}\nconst result = {func}();\nconsole.log("Test passed");'
                })
        
        return test_cases
    
    def _parse_test_output(self, output: str) -> List[Dict]:
        """Parse test output for detailed results"""
        details = []
        
        # Parse Python unittest output
        lines = output.split('\n')
        for line in lines:
            if 'FAIL:' in line or 'ERROR:' in line:
                details.append({
                    'status': 'failed',
                    'message': line.strip()
                })
            elif 'ok' in line and 'test' in line.lower():
                details.append({
                    'status': 'passed',
                    'message': line.strip()
                })
        
        return details
    
    def _calculate_performance_score(self, execution_time: float) -> str:
        """Calculate performance score based on execution time"""
        if execution_time is None:
            return 'unknown'
        elif execution_time < 0.1:
            return 'excellent'
        elif execution_time < 0.5:
            return 'good'
        elif execution_time < 2.0:
            return 'average'
        else:
            return 'poor'
    
    def _get_severity(self, vulnerability_type: str) -> str:
        """Get severity level for vulnerability type"""
        severity_map = {
            'sql_injection': 'critical',
            'code_injection': 'critical',
            'hardcoded_secrets': 'high',
            'path_traversal': 'high',
            'xss': 'medium'
        }
        return severity_map.get(vulnerability_type, 'low')
    
    def _get_security_description(self, vulnerability_type: str) -> str:
        """Get description for vulnerability type"""
        descriptions = {
            'sql_injection': 'Potential SQL injection vulnerability',
            'code_injection': 'Potential code injection vulnerability',
            'hardcoded_secrets': 'Hardcoded secret detected',
            'path_traversal': 'Potential path traversal vulnerability',
            'xss': 'Potential XSS vulnerability'
        }
        return descriptions.get(vulnerability_type, 'Security issue detected')
    
    def _calculate_security_score(self, issues: List[Dict]) -> int:
        """Calculate security score based on issues"""
        if not issues:
            return 100
        
        score = 100
        for issue in issues:
            severity = issue['severity']
            if severity == 'critical':
                score -= 30
            elif severity == 'high':
                score -= 20
            elif severity == 'medium':
                score -= 10
            elif severity == 'low':
                score -= 5
        
        return max(0, score)

"""
Code Comparator Utility for Code Assistant Bot
Author: RSK World (https://rskworld.in)
Founder: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
"""

import difflib
from typing import Dict, List, Any, Tuple

class CodeComparator:
    """
    Utility class for comparing code differences
    """
    
    def __init__(self):
        pass
    
    def compare_code(self, code1: str, code2: str, language: str = 'auto') -> Dict[str, Any]:
        """
        Compare two code snippets and show differences
        """
        try:
            lines1 = code1.splitlines(keepends=True)
            lines2 = code2.splitlines(keepends=True)
            
            # Use difflib to find differences
            diff = list(difflib.unified_diff(
                lines1, lines2,
                fromfile='Original',
                tofile='Modified',
                lineterm=''
            ))
            
            # Calculate statistics
            added_lines = sum(1 for line in diff if line.startswith('+') and not line.startswith('+++'))
            removed_lines = sum(1 for line in diff if line.startswith('-') and not line.startswith('---'))
            modified_blocks = self._count_modified_blocks(diff)
            
            # Generate HTML diff
            html_diff = self._generate_html_diff(lines1, lines2)
            
            # Generate side-by-side comparison
            side_by_side = self._generate_side_by_side(lines1, lines2)
            
            return {
                'success': True,
                'diff': diff,
                'html_diff': html_diff,
                'side_by_side': side_by_side,
                'statistics': {
                    'total_lines_original': len(lines1),
                    'total_lines_modified': len(lines2),
                    'lines_added': added_lines,
                    'lines_removed': removed_lines,
                    'lines_unchanged': len(lines1) - removed_lines,
                    'modified_blocks': modified_blocks,
                    'similarity_ratio': difflib.SequenceMatcher(None, code1, code2).ratio()
                }
            }
            
        except Exception as e:
            return {
                'success': False,
                'error': f'Code comparison failed: {str(e)}',
                'diff': [],
                'statistics': {}
            }
    
    def _count_modified_blocks(self, diff: List[str]) -> int:
        """Count number of modified blocks in diff"""
        blocks = 0
        in_block = False
        
        for line in diff:
            if line.startswith('@@'):
                if in_block:
                    blocks += 1
                in_block = True
            elif line.startswith(' ') and in_block:
                in_block = False
        
        if in_block:
            blocks += 1
        
        return blocks
    
    def _generate_html_diff(self, lines1: List[str], lines2: List[str]) -> str:
        """Generate HTML formatted diff"""
        diff = list(difflib.unified_diff(
            lines1, lines2,
            fromfile='Original',
            tofile='Modified',
            lineterm=''
        ))
        
        html = '<div class="diff-container">\n'
        html += '<pre class="diff">\n'
        
        for line in diff:
            if line.startswith('+++') or line.startswith('---'):
                html += f'<span class="diff-header">{line}</span>\n'
            elif line.startswith('@@'):
                html += f'<span class="diff-hunk">{line}</span>\n'
            elif line.startswith('+'):
                html += f'<span class="diff-added">{line}</span>\n'
            elif line.startswith('-'):
                html += f'<span class="diff-removed">{line}</span>\n'
            else:
                html += f'<span class="diff-context">{line}</span>\n'
        
        html += '</pre>\n'
        html += '</div>\n'
        
        return html
    
    def _generate_side_by_side(self, lines1: List[str], lines2: List[str]) -> List[Dict[str, Any]]:
        """Generate side-by-side comparison"""
        matcher = difflib.SequenceMatcher(None, lines1, lines2)
        comparison = []
        
        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
            if tag == 'equal':
                for i in range(i1, i2):
                    comparison.append({
                        'type': 'equal',
                        'left': lines1[i],
                        'right': lines2[i1 + (i - i1)],
                        'line_number_left': i + 1,
                        'line_number_right': i1 + (i - i1) + 1
                    })
            elif tag == 'delete':
                for i in range(i1, i2):
                    comparison.append({
                        'type': 'delete',
                        'left': lines1[i],
                        'right': '',
                        'line_number_left': i + 1,
                        'line_number_right': None
                    })
            elif tag == 'insert':
                for j in range(j1, j2):
                    comparison.append({
                        'type': 'insert',
                        'left': '',
                        'right': lines2[j],
                        'line_number_left': None,
                        'line_number_right': j + 1
                    })
            elif tag == 'replace':
                max_len = max(i2 - i1, j2 - j1)
                for k in range(max_len):
                    comparison.append({
                        'type': 'replace',
                        'left': lines1[i1 + k] if k < (i2 - i1) else '',
                        'right': lines2[j1 + k] if k < (j2 - j1) else '',
                        'line_number_left': i1 + k + 1 if k < (i2 - i1) else None,
                        'line_number_right': j1 + k + 1 if k < (j2 - j1) else None
                    })
        
        return comparison

"""
Code Analyzer Utility for Code Assistant Bot
Author: RSK World (https://rskworld.in)
Founder: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
"""

import re
import ast
import json
from typing import Dict, List, Any

class CodeAnalyzer:
    """
    Utility class for analyzing code quality, complexity, and metrics
    """
    
    def __init__(self):
        self.complexity_thresholds = {
            'low': 5,
            'medium': 10,
            'high': 20
        }
    
    def analyze(self, code: str, language: str) -> Dict[str, Any]:
        """
        Analyze code and return comprehensive metrics
        """
        try:
            analysis = {
                'metrics': self._calculate_metrics(code, language),
                'complexity': self._analyze_complexity(code, language),
                'quality': self._assess_quality(code, language),
                'suggestions': self._generate_suggestions(code, language),
                'security': self._check_security_issues(code, language)
            }
            
            return analysis
            
        except Exception as e:
            return {
                'error': f'Analysis failed: {str(e)}',
                'metrics': {},
                'complexity': {},
                'quality': {},
                'suggestions': [],
                'security': []
            }
    
    def _calculate_metrics(self, code: str, language: str) -> Dict[str, int]:
        """
        Calculate basic code metrics
        """
        lines = code.split('\n')
        
        metrics = {
            'total_lines': len(lines),
            'code_lines': len([line for line in lines if line.strip() and not line.strip().startswith('#')]),
            'comment_lines': len([line for line in lines if line.strip().startswith('#')]),
            'blank_lines': len([line for line in lines if not line.strip()]),
            'functions': self._count_functions(code, language),
            'classes': self._count_classes(code, language),
            'imports': self._count_imports(code, language)
        }
        
        return metrics
    
    def _analyze_complexity(self, code: str, language: str) -> Dict[str, Any]:
        """
        Analyze code complexity
        """
        complexity = {
            'cyclomatic_complexity': self._calculate_cyclomatic_complexity(code, language),
            'cognitive_complexity': self._calculate_cognitive_complexity(code, language),
            'nesting_depth': self._calculate_nesting_depth(code, language),
            'complexity_level': 'low'
        }
        
        # Determine complexity level
        max_complexity = max(
            complexity['cyclomatic_complexity'],
            complexity['cognitive_complexity']
        )
        
        if max_complexity <= self.complexity_thresholds['low']:
            complexity['complexity_level'] = 'low'
        elif max_complexity <= self.complexity_thresholds['medium']:
            complexity['complexity_level'] = 'medium'
        else:
            complexity['complexity_level'] = 'high'
        
        return complexity
    
    def _assess_quality(self, code: str, language: str) -> Dict[str, Any]:
        """
        Assess code quality
        """
        quality = {
            'score': 0,
            'readability': self._assess_readability(code, language),
            'maintainability': self._assess_maintainability(code, language),
            'documentation': self._assess_documentation(code, language),
            'testing': self._assess_testing(code, language)
        }
        
        # Calculate overall quality score
        quality['score'] = (
            quality['readability'] * 0.3 +
            quality['maintainability'] * 0.3 +
            quality['documentation'] * 0.2 +
            quality['testing'] * 0.2
        )
        
        return quality
    
    def _generate_suggestions(self, code: str, language: str) -> List[str]:
        """
        Generate improvement suggestions
        """
        suggestions = []
        
        # Check for long lines
        lines = code.split('\n')
        long_lines = [i+1 for i, line in enumerate(lines) if len(line) > 80]
        if long_lines:
            suggestions.append(f"Consider breaking lines {long_lines[:3]} into shorter lines (max 80 characters)")
        
        # Check for missing docstrings (Python specific)
        if language == 'python':
            functions = self._extract_functions(code)
            for func in functions:
                if not func.get('docstring'):
                    suggestions.append(f"Function '{func['name']}' is missing a docstring")
        
        # Check for TODO/FIXME comments
        todo_patterns = [r'#\s*TODO', r'#\s*FIXME', r'//\s*TODO', r'//\s*FIXME']
        for pattern in todo_patterns:
            if re.search(pattern, code, re.IGNORECASE):
                suggestions.append("Code contains TODO/FIXME comments that need attention")
        
        # Check for duplicate code
        if self._has_duplicate_code(code):
            suggestions.append("Consider refactoring duplicate code into reusable functions")
        
        return suggestions
    
    def _check_security_issues(self, code: str, language: str) -> List[Dict[str, str]]:
        """
        Check for common security issues
        """
        security_issues = []
        
        # Check for hardcoded passwords/secrets
        secret_patterns = [
            r'password\s*=\s*["\'][^"\']+["\']',
            r'api_key\s*=\s*["\'][^"\']+["\']',
            r'secret\s*=\s*["\'][^"\']+["\']',
            r'token\s*=\s*["\'][^"\']+["\']'
        ]
        
        for pattern in secret_patterns:
            matches = re.finditer(pattern, code, re.IGNORECASE)
            for match in matches:
                security_issues.append({
                    'type': 'hardcoded_secret',
                    'severity': 'high',
                    'line': code[:match.start()].count('\n') + 1,
                    'description': 'Potential hardcoded secret detected'
                })
        
        # Check for SQL injection vulnerabilities
        sql_patterns = [
            r'execute\s*\(\s*["\'][^"\']*%[^"\']*["\']',
            r'query\s*\(\s*["\'][^"\']*%[^"\']*["\']'
        ]
        
        for pattern in sql_patterns:
            if re.search(pattern, code, re.IGNORECASE):
                security_issues.append({
                    'type': 'sql_injection',
                    'severity': 'high',
                    'description': 'Potential SQL injection vulnerability'
                })
        
        return security_issues
    
    def _count_functions(self, code: str, language: str) -> int:
        """Count number of functions in code"""
        if language == 'python':
            return len(re.findall(r'def\s+\w+\s*\(', code))
        elif language in ['javascript', 'typescript']:
            return len(re.findall(r'function\s+\w+\s*\(|const\s+\w+\s*=\s*\(', code))
        elif language == 'java':
            return len(re.findall(r'(public|private|protected)?\s*(static)?\s*\w+\s+\w+\s*\(', code))
        return 0
    
    def _count_classes(self, code: str, language: str) -> int:
        """Count number of classes in code"""
        if language == 'python':
            return len(re.findall(r'class\s+\w+', code))
        elif language in ['java', 'csharp', 'cpp']:
            return len(re.findall(r'class\s+\w+', code))
        elif language in ['javascript', 'typescript']:
            return len(re.findall(r'class\s+\w+', code))
        return 0
    
    def _count_imports(self, code: str, language: str) -> int:
        """Count number of import statements"""
        if language == 'python':
            return len(re.findall(r'^(import|from)\s+', code, re.MULTILINE))
        elif language in ['java', 'javascript', 'typescript']:
            return len(re.findall(r'^(import)\s+', code, re.MULTILINE))
        elif language == 'cpp':
            return len(re.findall(r'^#include', code, re.MULTILINE))
        return 0
    
    def _calculate_cyclomatic_complexity(self, code: str, language: str) -> int:
        """Calculate cyclomatic complexity"""
        complexity = 1  # Base complexity
        
        # Count decision points
        decision_patterns = [
            r'\bif\b', r'\belse\b', r'\belif\b', r'\bwhile\b', 
            r'\bfor\b', r'\bcase\b', r'\bcatch\b', r'\?'
        ]
        
        for pattern in decision_patterns:
            complexity += len(re.findall(pattern, code))
        
        return complexity
    
    def _calculate_cognitive_complexity(self, code: str, language: str) -> int:
        """Calculate cognitive complexity (simplified version)"""
        complexity = 0
        
        # Count nesting and control flow
        lines = code.split('\n')
        nesting_level = 0
        
        for line in lines:
            stripped = line.strip()
            
            # Increase nesting
            if any(keyword in stripped for keyword in ['if', 'for', 'while', 'try', 'with']):
                complexity += 1 + nesting_level
                nesting_level += 1
            elif any(keyword in stripped for keyword in ['else', 'elif', 'except', 'finally']):
                complexity += 1 + nesting_level
            
            # Decrease nesting
            if stripped.endswith(':') or '}' in stripped:
                nesting_level = max(0, nesting_level - 1)
        
        return complexity
    
    def _calculate_nesting_depth(self, code: str, language: str) -> int:
        """Calculate maximum nesting depth"""
        max_depth = 0
        current_depth = 0
        
        lines = code.split('\n')
        for line in lines:
            stripped = line.strip()
            
            if any(keyword in stripped for keyword in ['if', 'for', 'while', 'try', 'with']):
                current_depth += 1
                max_depth = max(max_depth, current_depth)
            elif any(keyword in stripped for keyword in ['else', 'elif', 'except', 'finally']):
                max_depth = max(max_depth, current_depth)
            elif '}' in stripped or stripped.endswith(':'):
                current_depth = max(0, current_depth - 1)
        
        return max_depth
    
    def _assess_readability(self, code: str, language: str) -> float:
        """Assess code readability (0-100 score)"""
        score = 100.0
        
        # Deduct for long lines
        lines = code.split('\n')
        long_lines = [line for line in lines if len(line) > 80]
        score -= min(20, len(long_lines) * 2)
        
        # Deduct for lack of comments
        comment_ratio = len([line for line in lines if line.strip().startswith('#')]) / len(lines)
        if comment_ratio < 0.1:
            score -= 15
        
        # Deduct for complex naming
        if re.search(r'[a-z]\d+[A-Z]', code):  # CamelCase with numbers
            score -= 10
        
        return max(0, score)
    
    def _assess_maintainability(self, code: str, language: str) -> float:
        """Assess code maintainability (0-100 score)"""
        score = 100.0
        
        # Deduct for high complexity
        complexity = self._calculate_cyclomatic_complexity(code, language)
        if complexity > 10:
            score -= min(30, (complexity - 10) * 3)
        
        # Deduct for long functions
        if language == 'python':
            functions = self._extract_functions(code)
            for func in functions:
                if func['length'] > 50:
                    score -= 10
        
        return max(0, score)
    
    def _assess_documentation(self, code: str, language: str) -> float:
        """Assess code documentation (0-100 score)"""
        score = 100.0
        
        lines = code.split('\n')
        total_lines = len([line for line in lines if line.strip()])
        comment_lines = len([line for line in lines if line.strip().startswith('#')])
        
        if total_lines > 0:
            comment_ratio = comment_lines / total_lines
            if comment_ratio < 0.1:
                score -= 50
            elif comment_ratio < 0.2:
                score -= 25
        
        return max(0, score)
    
    def _assess_testing(self, code: str, language: str) -> float:
        """Assess testing coverage (simplified)"""
        score = 100.0
        
        # Check for test-related keywords
        test_patterns = [
            r'test_', r'spec_', r'describe\(', r'it\(', r'assert', r'expect'
        ]
        
        has_tests = any(re.search(pattern, code, re.IGNORECASE) for pattern in test_patterns)
        if not has_tests:
            score -= 100
        
        return max(0, score)
    
    def _extract_functions(self, code: str) -> List[Dict[str, Any]]:
        """Extract function information (Python specific)"""
        functions = []
        
        try:
            tree = ast.parse(code)
            for node in ast.walk(tree):
                if isinstance(node, ast.FunctionDef):
                    functions.append({
                        'name': node.name,
                        'line': node.lineno,
                        'length': node.end_lineno - node.lineno if hasattr(node, 'end_lineno') else 0,
                        'docstring': ast.get_docstring(node) is not None
                    })
        except:
            pass
        
        return functions
    
    def _has_duplicate_code(self, code: str) -> bool:
        """Check for duplicate code blocks (simplified)"""
        lines = [line.strip() for line in code.split('\n') if line.strip()]
        
        # Simple check for repeated lines
        line_counts = {}
        for line in lines:
            if len(line) > 10:  # Ignore short lines
                line_counts[line] = line_counts.get(line, 0) + 1
        
        # If any line appears more than twice, consider it duplicate
        return any(count > 2 for count in line_counts.values())