"""
ADVANCED CODE BUILDER V2 - Fixed Pattern Matching
"""

import ast
import time
from typing import Dict, Any, List

class AdvancedCodeBuilder:
    """Real code generation with comprehensive patterns"""
    
    def __init__(self):
        self.patterns = self._load_patterns()
        print(f"🔧 Advanced Code Builder V2 - {len(self.patterns)} patterns loaded")
    
    def _load_patterns(self) -> Dict:
        """Load comprehensive code patterns"""
        # [Keep all the same patterns from before]
        return {
            'pattern_analyzer': '''def _process(self, task: str, context: Dict) -> Any:
    data = context.get('data', [])
    if not data:
        return {'error': 'No data', 'patterns': []}
    patterns = []
    if len(data) > 2:
        for i in range(len(data) - 1):
            if data[i] == data[i+1]:
                patterns.append({'type': 'repetition', 'index': i})
    return {'patterns': patterns, 'count': len(patterns)}''',
            
            'reasoning_engine': '''def _process(self, task: str, context: Dict) -> Any:
    premises = context.get('premises', [task])
    reasoning_chain = []
    for premise in premises:
        analysis = {'premise': str(premise), 'confidence': 0.8}
        reasoning_chain.append(analysis)
    return {'reasoning_chain': reasoning_chain, 'steps': len(reasoning_chain)}''',
            
            'strategic_planner': '''def _process(self, task: str, context: Dict) -> Any:
    goals = context.get('goals', [task])
    plan = {'objective': task, 'goals': goals, 'steps': []}
    for idx, goal in enumerate(goals):
        step = {'step_number': idx + 1, 'goal': str(goal), 'priority': 1.0/(idx+1)}
        plan['steps'].append(step)
    return plan''',
            
            'optimization_engine': '''def _process(self, task: str, context: Dict) -> Any:
    variables = context.get('variables', {})
    iterations = []
    for i in range(5):
        score = sum(v if isinstance(v, (int,float)) else 1 for v in variables.values())
        iterations.append({'iteration': i, 'score': score})
    return {'optimal_solution': variables, 'iterations': len(iterations)}''',
            
            'meta_learner': '''def _process(self, task: str, context: Dict) -> Any:
    history = context.get('history', [])
    analysis = {'success_rate': 0.0}
    if history:
        successes = sum(1 for h in history if h.get('success'))
        analysis['success_rate'] = successes / len(history)
    return {'analysis': analysis, 'learning_velocity': len(history)}''',
            
            'creative_synthesizer': '''def _process(self, task: str, context: Dict) -> Any:
    ideas = context.get('ideas', [task])
    combinations = []
    for i, idea1 in enumerate(ideas):
        for j, idea2 in enumerate(ideas):
            if i < j:
                combinations.append({'idea1': str(idea1), 'idea2': str(idea2)})
    return {'combinations': combinations[:10], 'total': len(combinations)}''',
            
            'abstraction_builder': '''def _process(self, task: str, context: Dict) -> Any:
    concepts = context.get('concepts', task.split())
    groups = {}
    for concept in concepts:
        key = str(concept)[0] if concept else 'other'
        if key not in groups:
            groups[key] = []
        groups[key].append(concept)
    return {'base_concepts': concepts, 'groups': groups, 'levels': 1}''',
            
            'problem_decomposer': '''def _process(self, task: str, context: Dict) -> Any:
    subproblems = []
    if 'and' in task.lower():
        subproblems = [s.strip() for s in task.split('and')]
    elif ',' in task:
        subproblems = [s.strip() for s in task.split(',')]
    else:
        subproblems = [task]
    return {'original': task, 'subproblems': subproblems, 'count': len(subproblems)}''',
            
            'hypothesis_generator': '''def _process(self, task: str, context: Dict) -> Any:
    observations = context.get('observations', [task])
    hypotheses = []
    for obs in observations:
        hyp = {'observation': str(obs), 'hypothesis': f"If {obs}, then...", 'testable': True}
        hypotheses.append(hyp)
    return {'hypotheses': hypotheses, 'count': len(hypotheses)}''',
            
            'knowledge_integrator': '''def _process(self, task: str, context: Dict) -> Any:
    sources = context.get('sources', [])
    integrated = {'sources_count': len(sources), 'combined_data': []}
    for idx, source in enumerate(sources):
        integrated['combined_data'].append({'index': idx, 'data': str(source)})
    return integrated'''
        }
    
    def generate_implementation(self, purpose: str) -> str:
        """Generate working code from patterns with keyword matching"""
        purpose_lower = purpose.lower()
        
        # Keyword mapping
        keywords = {
            'pattern': 'pattern_analyzer', 'detect': 'pattern_analyzer', 'analyze': 'pattern_analyzer',
            'reasoning': 'reasoning_engine', 'logic': 'reasoning_engine', 'reason': 'reasoning_engine',
            'plan': 'strategic_planner', 'strategy': 'strategic_planner', 'strategic': 'strategic_planner',
            'optim': 'optimization_engine', 'optimal': 'optimization_engine',
            'learn': 'meta_learner', 'meta': 'meta_learner',
            'creative': 'creative_synthesizer', 'synthesize': 'creative_synthesizer',
            'abstract': 'abstraction_builder', 'hierarchy': 'abstraction_builder',
            'decompose': 'problem_decomposer', 'break': 'problem_decomposer', 'split': 'problem_decomposer',
            'hypothesis': 'hypothesis_generator', 'generate': 'hypothesis_generator',
            'integrate': 'knowledge_integrator', 'connect': 'knowledge_integrator'
        }
        
        for keyword, pattern_name in keywords.items():
            if keyword in purpose_lower:
                print(f"   📚 {pattern_name} (keyword: {keyword})")
                return self.patterns[pattern_name]
        
        print(f"   🔨 Generic fallback")
        return f'''def _process(self, task: str, context: Dict) -> Any:
    return {{'task': task, 'purpose': '{purpose}', 'processed': True}}'''
    
    def test_code(self, code: str) -> bool:
        try:
            ast.parse(code)
            return 'def _process' in code and 'return' in code
        except:
            return False